An incentive-based multicast route construction scheme for recipient maximization in wireless relay networks

2.1. Multicast schemes

A great deal of research has been conducted on multicast issues in wireless networks. For example, Lee and Cho [6] designed a reliable multicast scheme using Code Division Multiple Access (CDMA) codes in WiMAX networks; She et al. [7] proposed a two-level superposition coded multicast scheme (2-level SCM) to improve the channel efficiency of multicast transmissions in a WiMAX network; and Zhao et al. [8] studied the power allocation issue to achieve robust multicast communication in CDMA-based wireless networks. In addition to multicast schemes for wireless networks, a class of allocation problems called Minimum-Energy Multicast (MEM) has been well studied in a number of studies, such as [9–12]. Given the channel condition of each node, the MEM problem finds the multicast tree that minimizes the total energy required to deliver a stream to a given set of subscribers. Although MEM appears to be similar to our maximization problem (i.e., MHMM), the approaches are substantially different. First, most studies of MEM assume that each intermediate node can forward data; however, only RSs can relay data in MHMM relay networks. Second, MEM minimizes the resource required to serve subscribers, whereas MHMM maximizes the number of recipients that can be served with a limited budget. Third, under MEM, it is assumed that each node receives a separate copy of the data from the sender, but MHMM allows SSs to receive data as long as the channel quality permits. Therefore, if the resource for a multicast program is limited due to the network's resource management policy, MHMM should be adopted to solve the problem instead of MEM.

2.2. Selfish behavior of nodes

The problem caused by nodes' selfish behavior has long been recognized by the mobile ad hoc network community, and several mechanisms that encourage cooperation have been proposed [13]. Existing approaches may be reputation-based (e.g., [14–19]), where the behavior of each node is monitored and non-cooperative nodes (including selfish and malicious ones) are penalized; or they may be payment-based (e.g., [19–22]), where some virtual currency is introduced to encourage packet forwarding to other nodes. Other issues addressed in existing works include preventing cheating [20, 21] and collusion [19]. However, the above approaches only encourage selfish agents to participate in routing or forwarding operations. They do not consider multicast transmission, so they are not suitable for the MHMM problem.

To date, very few studies have tried to solve the multicast recipient maximization problem in wireless relay networks containing selfish nodes. In [23], the authors propose a truthful multicast routing scheme for selfish wireless networks. By reporting the cost of each link, each node decides independently the route that will maximize its benefit. Since this study tries to solve the MEM problem, it differs from our approach. Wei and Gilin[24] presented a cooperative relay scheme for a WWAN/WLAN two-hop relay network. A selfish dual-mode terminal can be encouraged to relay data by payment from other nodes. However, under this scheme, each node, including each mobile user, can work as a relay node, and the scale of the network is limited to only two hops. Most importantly, none of the above studies consider AMC. Therefore, they let each sender transmit a stream separately to each receiver instead of multicasting it only once. In contrast, under our model, a transmitted stream can be received simultaneously by several subscribers as long as the channel conditions allow. Lee et al. [25] proposed an incentive-based transmission framework to maintain fairness in multi-hop wireless backhaul networks with selfish Transit Access Points. It is not suitable for our multicast scenario because the mechanism is designed for maintaining fairness between unicast traffic.

3.1. System models

Wireless relay networks utilize different types of wireless resources. Our scheme can be applied in a variety of wireless relay networks because it is modeled in a general way. Without loss of generality, the resource in our model refers to the amount of the transmission medium that can be distributed and utilized by different nodes. Therefore, depending on the physical design of the wireless network, the resource can be the number of timeslots, subchannels, or transmission codes. For example, the resource of a WiMAX network refers to the number of timeslots in a downlink subframe; while in a Wi-Fi network, it may be the amount of transmission time in the contention-free period. The budget of a multicast program means the maximal usable resource of the service, which may be predetermined by the system or left by other high-priority traffic. A fixed budget is given to each multicast service for distribution between the BS and the RSs. We denote this stream budget by r_budget.

In this article, we consider general wireless relay networks in which an RS can act as a relay for other RSs. The SSs can receive a multicast stream from the BS directly, or from one of the RSs via one-hop or multi-hop relays. Let the number of RSs and the number of SSs be M and N, respectively. Each node is labeled with a unique integer for identification purposes. In addition, let node 0 be the BS, nodes 1 to M be the RSs, and nodes M + 1 to node M + N be the SSs. Since the proposed scheme supports AMC, we assume that the minimum resource required to transmit a stream successfully is different for each node. Given the data rate of the stream and that of the coding method, we can determine the amount of the resource consumed when transmitting the stream with the coding method. Let r _i,j denote the resource required to transmit a multicast stream from node i to j. In an AMC-supported network, where the channel conditions between the nodes are monitored and the coding method is adjusted accordingly, specifying r _i,j between each pair of nodes allows different transmission capacities, channel models, and attenuation conditions to be tolerated. If a stream is transmitted by i with resource r, all nodes j that have r _i,j ≤ r can decode the stream successfully because the coding method utilized by the nodes' channels is not slower than that used by i. Taking the WiMAX network as an example, based on the channel quality, each channel has a different Burst Profile, which records its acceptable modulation schemes and therefore the transmission speed. If a multicast stream is encoded by a certain coding method (i.e., it takes a certain number of timeslots), all receivers whose channels allow a faster scheme (i.e., they require fewer timeslots) will be able to decode the stream successfully.

Next, let $\Re =\left[r_0,r_1,...,r_M\right]$ be the resource allocation of the senders (i.e., the BS and the RSs), where r _m is the resource allocated to the m th sender for the multicast service 0 ≤ m ≤ M. Without loss of generality, we allow the RSs to be placed in the order of the required resource, i.e., r_0,1 ≤ r_0,2 ≤ ... ≤ r_0,M. If a sender, say sender m, is allocated the resource r _m , each SS and RS whose resource requirement is less than r _m can receive the data simultaneously from m. To describe the reach ability of senders, the binary function $D_m\left(\Re \right)$, 0 ≤ m ≤ M, indicates whether m can receive the stream originating from the BS when the allocation $\Re$ is given. Since we consider general wireless relay networks in which an RS can act as a relay for other RSs, the value of $D_m\left(\Re \right)$ is 1 if there exists an RS m' that satisfies the following conditions: (i) node m is within the transmission range of m'; (ii) $D_{m^{\prime }}\left(\Re \right)=1$ (i.e., node m' can receive the stream from the BS); and (iii) r _m',m ≤ r _m' (i.e., m can receive the stream from m'), where 0 ≤ m' ≤ M.

Given an allocation $\Re$ and the channel conditions of the network (i.e., r _i,j for all i and j,) the value of $D_m\left(\Re \right)$ for all senders (i.e., all nodes m ≤ M) can be derived easily as follows. Initially, the value of $D_m\left(\Re \right)$ for all m > 0 is set at 0, while $D_0\left(\Re \right)=1$ because the BS can always receive the stream irrespective of the value of $\Re$. Then, all unserved RSs (i.e., $D_m\left(\Re \right)=0$) in the transmission range of the BS that can receive the stream from the BS (i.e., all m where r_0,m≤ r₀) set their $D_m\left(\Re \right)$ value to 1. Next, all unserved RSs that can receive the stream from served senders (all m that can find a 0 ≤ m' ≤ M that satisfies $r_{m^{\prime },m}\le r_{m^{\prime }}$ and $D_{m^{\prime }}\left(\Re \right)=1$) are included. This process is repeated until no more RSs can be included. Given an allocation $\Re$, it takes O (M²) steps to compute $D_m\left(\Re \right)$ for all m because at most m senders have to be checked in each round. The process is repeated at most M rounds, since one sender is included in each round. We introduce another unit-step function U(·) to determine whether an SS can receive the stream from either the BS or one of the RSs. The value of U(x) is 1 if x ≥ x; otherwise, U(x) = 0. Then, $D_m\left(\Re \right)U\left(r_m-r_{m,n}\right)$ shows if the SS n can receive the stream from node m.

3.2. Problem specification

With the above notations, we formally define our MHMM problem as follows.

Definition 3.1 MHMM involves finding $\Re =\left[r_0,r_1,...,r_M\right]$ that maximizes ${\sum }_{n=M+1}^{M+N}\mathsf{\text{min}}\left[1,{\sum }_{m=0}^M{D}_m\left(\Re \right)U\left(r_m-r_{m,n}\right)\right]$ with a given budget r_budget and r _i,j , 0 ≤i, j ≤ M + N, subject to ${\sum }_{m=0}^M{r}_m\le r_{\mathsf{\text{budget}}}$ and r _m ≥ o for all 0 ≤ m ≤ M.

Since $D_m\left(\Re \right)U\left(r_m-r_{m,n}\right)$ shows if an SS n can receive a stream from the m th RS, the value of $\mathsf{\text{min}}\left[1,{\sum }_{m=0}^M{D}_m\left(\Re \right)U\left(r_m-r_{m,n}\right)\right]$ is 1 if there exists at least one route from node 0 to node n that allows the n th SS to receive the stream: otherwise, the value is 0. Therefore, the objective function ${\sum }_{n=M+1}^{M+N}\mathsf{\text{min}}\left[1,{\sum }_{m=0}^M{D}_m\left(\Re \right)U\left(r_m-r_{m,n}\right)\right]$ refers to the number of SSs that can receive the multicast stream given the allocation $\Re$.

The following theorem proves that MHMM is NP-complete.

Theorem 3.1 MHMM is NP-complete.

Proof:

To prove that MHMM is NP-complete, we consider another problem called Single-Hop Multicast Maximization (SHMM). Similar to MHMM, SHMM tries to maximize the number of recipients with a given resource budget. The only difference is that SHMM is limited to one-hop relay, i.e., RSs can only relay data between the BS and the SSs; they cannot forward data for other RSs.

SHMM can be reduced from a well-known NP-complete problem called Maximum Coverage [26]. Given a number k and a collection of sets S = {S₁, S₂, ..., e _N }, where S _m ⊆ {e₁, e₂, ..., e _N } for all 1 ≤ m ≤ M, Maximum Coverage finds a subset S' ⊆ S such that |S'| ≤ k and the number of the elements it covers (i.e., $\left|\bigcup _{S_i\in S^{\prime }}{S}_i\right|$,) is maximized. Any instance of the Maximum Coverage problem can be reduced to an instance of SHMM by transforming each element and set into an SS and an RS (with a subordinate group of SSs), respectively. As shown in Figure 2, the resource required for the BS to serve each RS is 0, while that for each RS _m to serve its associated SSs (i.e., elements in S _m ) is 1. Therefore, any instance of the Maximum Coverage problem (i.e., the set number limitation, the elements, and the collection of sets) can be mapped to an instance of SHMM (i.e., the resource budget, the SSs, and the servable SSs of each RS). In the transformed instance, maximizing the number of elements covered under the set number limitation can be transformed into maximizing the number of recipients subject to the resource budget. Since the input size of both problems is O(MN), the reduction process is in polynomial time. This means SHMM is more general than Maximum Coverage, which is known to be NP-hard; therefore, SHMM is also NP-hard.

Next, we verify that SHMM is a special case of MHMM. If we let the required resource between each pair of RSs be larger than the limited budget (i.e., $r_{m_1,m_2}>r_{\mathsf{\text{budget}}}$ for all 0 < m₁, m₂ ≤ M) in SHMM, the RSs cannot relay data for each other. Consequently, any instance of SHMM is an instance of MHMM. Therefore, MHMMis more general than SHMM, so it is also NP-hard.

On the other hand, MHMM is also NP. Given a resource allocation $\Re =\left[r_0,r_1,...,r_M\right]$, the number of recipients the system can serve is ${\sum }_{n=M+1}^{M+N}\mathsf{\text{min}}\left[1,{\sum }_{m=0}^M{D}_m\left(\Re \right)U\left(r_m-r_{m,n}\right)\right]$. The complexity of the whole computation process is O(M³N) because, as mentioned in Section3.1, the complexity of finding $D_m\left(\Re \right)$ for all m is O(M²), and it takes O(MN) steps to sum $D_m\left(\Re \right)U\left(r_m-r_{m,n}\right)$ for all m and n. As the performance of a solution can be verified in polynomial time, MHMM is NP; and because MHMM is both NP-hard and NP, it is also NP-complete.

From the above proof, we know that even when transmissions are only possible from the BS to RSs, the maximization problem is already NP-hard. However, in a real-world scenario, where RSs are within each other's transmission range, the problem becomes much more difficult because there are more possible allocation options. To address this problem, we propose a low-overhead incentive-based resource allocation scheme that solves the MHMM problem efficiently and effectively in wireless relay networks with selfish nodes.

4.1. Business model and proposed scheme

Before discussing the proposed scheme, we describe the business model. To distribute the wireless resource efficiently, we adopt the concept of the Bandwidth Broker (BB) proposed in [27]. The BB is operated by the network carrier or service provider that owns the radio bandwidth. The value of the unit price is discrete and chosen by the BB from a predetermined matrix $P=\left[p_1,p_2,...,p_{I_{\mathsf{\text{max}}}}\right]$, where I_max is the number of price options. To transmit a stream and earn revenue from the SSs, each sender must submit its resource requirement under each unit price(i.e., required resources under P _i , i = 1 to I_max) to the BB. After the BB decides the final unit price and allocates the resources, the senders use the acquired resources to deliver the streaming content and derive their profit from the SSs, which pay their respective senders a fixed price (i.e., p_stream) for the received data. However, when the channel quality is good enough, each RS can receive the stream from other senders free of charge because the stream is subscribed by the SSs and has no utility to the RS itself. Figure 3 shows an example of the relationship between the BS, RSs, SSs, and the BB in a network.

The pseudo-code of IBRC is shown in Figure 4. Since the BB is the core agent of the proposed procedure, it executes the main function of IBRC. For all possible unit prices P _i , i = 1, 2, ..., I_max, the BB implements the algorithm to query all senders in order to determine the amount of the resource each one wants to buy under unit price P _i . It then decides the final allocation (i.e., ${\Re }^i$). To distinguish between processed and unprocessed nodes, we let array asked_RS record if the RSs have been queried already and served_SS indicate the SSs that have received the stream. Meanwhile, a binary array D records the current value of $D_m\left({\Re }^i\right)$ for all m.D is initialized as [1, 0, 0, ... 0] because only the BS (i.e., node 0) can receive the stream initially. Consequently, the BB always queries the BS first, and the value of D is updated by the function query, which we discuss later in this section. In the subsequent round of the do loop, the BB selects an available sender, which is a sender m that (1) has not been queried before (i.e., ask_RS[m] == 0), and (2) can receive the stream with the given allocation (i.e., D[m] == 1). It then queries the sender m for a bidding decision ($q_m^i$, served_SS_new, D _new ) via the function query and marks the array asked _RS[m] as 1. If more than one RS satisfies the above conditions, they are selected at random so that each sender is queried in a different order for different prices. As a result, a sender cannot block the service of other senders.

Based on the value of p_stream and served_SS, the queried sender m indicates its preferred resource $q_m^i$. To maximize its profit, m sets $q_m^i$ as $\mathsf{\text{arg}}\underset{r}{\mathsf{\text{max}}}\left[U\left(r\right)\left(p_{stream}\underset{\sum }{\overset{served\text{\_}SS\left[n\right]=0}{}}U\left(r-r_{m,n}\right)-r{p}_i\right)\right]$. If m is allocated the required resource, the arrays served_SS_new and D _new record the new served_SS and D, respectively. The steps of the procedure are shown in Figure 5. If $q_m^i\le r_{\mathsf{\text{available}}}$, the BB updates allocation ${\Re }^i=\left[r_0^i,r_1^i,...,r_M^i\right]$ by setting $r_m^i=q_m^i$, since the residual resource is still sufficient to serve m. It also updates served_SS and D with served_SS_new and D_new, respectively. The new served_SS and D are given to the sender queried in the next round. This procedure repeats until no more SSs can be served (i.e., include_node == 0) because all senders have been queried, or all SSs have been served, or the resource is exhausted. After obtaining the requested allocations under all prices (i.e., ${\Re }^i=\left[r_0^i,r_1^i,...,r_M^i\right]$, i = 1, 2, ..., I_max), the BB decides the unit price $p_{i_{set}}$ by setting i _set to $\mathsf{\text{arg}}\underset{i}{\mathsf{\text{max}}}\left(p_i\times \sum _{m=1}^M{r}_m^i\right)$. It then distributes the resource to each sender based on ${\Re }^{i_{set}}$.

As shown in Figure 5, each sender only participates if the allocation will be profitable. In other words, the revenue each sender receives from the SSs (i.e., P_stream N, where N is the number of SSs the sender serves,) must be greater than the price it pays the BB for the resource. Therefore, the preferred amount of resource it submits to the BB is proportional to the lower bound of the number of served users. For the BB, given the preferred resource $r_m^i$ of sender m under the unit price p _i , it can derive revenue of $p_i{r}_m^i$ and serve at least $\frac{p_i{r}_m^i}{p_{\mathsf{\text{stream}}}}$ senders. Therefore, under p _i , the total revenue that the BB can derivefrom all senders is ${\sum }_{i=0}^M{p}_i{r}_m^i$, and it can serve at least ${\sum }_{i=0}^M\frac{p_i{r}_m^i}{p_{\mathsf{\text{stream}}}}=\frac{1}{p_{\mathsf{\text{stream}}}}{\sum }_{i=0}^M{p}_i{r}_m^i$ SSs. Therefore, when the BB tries to maximize its revenue (i.e., ${\sum }_{i=0}^M{p}_i{r}_m^i$), it also maximizes the lower bound of the served SSs (i.e., $\frac{1}{p_{\mathsf{\text{stream}}}}{\sum }_{i=0}^M{p}_i{r}_m^i$). In other words, the BB sets the price to maximize the efficiency of global resource allocation among senders. Meanwhile, each sender attempts to maximize its profit by serving as many users as possible with the given resource.

Clearly, IBRC can utilize RSs to make resource allocation more efficient. As mentioned earlier, the BB queries each sender for its preferred resource under each price. Since the BS is always the first sender to be queried, it is always offered the same array served_SS = [0, 0, ..., 0], irrespective of the number of RSs in the network. Given the same served_SS and identical channel conditions r_0,M+1, r_0,M+2, ..., r_0,M+N, the BS always requests the same amount of the resource and serves the same number of SSs regardless of the number of RSs. Therefore, if there are RSs in the network, the SSs that were originally served by BS will always be served; while unserved SSs can be served by the RSs. This means that the performance of the RSs is always at least as good as that of the pure-BS approach.

4.2. Best strategies for each agent

As mentioned in Section 1, each agent is selfish, so its objective is to maximize its income. Therefore, we have to prove that the operation of IBRC can yield the maximum revenue so that each sender can operate as proposed under IBRC. In the analysis, we assume that each role in the system makes decisions in dependently, and no collusion occurs. In IBRC, the BB's strategy is to set the price index i _set as $\mathsf{\text{arg}}\underset{i}{\mathsf{\text{max}}}\left(p_i\times {\sum }_{m=1}^M{r}_m^i\right)$, as shown in the last two lines of Figure 4. The process implemented by each sender (i.e., function query) is detailed in Figure 5. The sender m sets the preferred resource $q_m^i$ as $\mathsf{\text{arg}}\underset{r}{\mathsf{\text{max}}}\left[U\left(r\right)\left(p_{stream}{}_{\sum }^{served\text{\_}SS\left[n\right]=0}U\left(r-r_{m,n}\right)-r{p}_i\right)\right]$, and returns arrays served_SS_new and D _new to indicate the changes to served_SS and D if it is allocated resource $q_m^i$. In Theorems 4.1 and 4.2, we prove that these functions yield the maximum profit; thus, they are the most effective strategies for the BB and the RSs, respectively.

Theorem 4.1 Setting i _set as $\mathsf{\text{arg}}\underset{i}{\mathsf{\text{max}}}\left(p_i{\sum }_{m=1}^M{r}_m^i\right)$ yields the highest expected revenue for the BB.

Proof:

If the radio resource is sold at unit price p_i, the BB's profit is the price p _i multiplied by the total amount of the resource consumed under p _i . Since the allocation under p _i is ${\Re }^i=\left[r_0^i,r_1^i,...,r_M^i\right]$, the total resource consumed is ${\sum }_{m=1}^M{r}_m^i$. To maximize its profit, the BB must choose the price p _i that maximizes the value of $\left(p_i{\sum }_{m=1}^M{r}_m^i\right)$. Therefore, the best price for the BB (i.e., i _set ) would be $i_{set}=\mathsf{\text{arg}}\underset{i}{\mathsf{\text{max}}}\left(p_i{\sum }_{m=1}^M{r}_m^i\right)$.

Theorem 4.2 The pseudo-code in Figure 5(i.e., acting truthfully) yields the highest expected revenue for each sender.

Proof:

In IBRC, the BB queries each sender for its preferred resource requirement under all prices (i.e., query(m, p_stream, p _i , served_SS, D)). To determine the amount of the resource that would maximize its profit, each sender m bases its decision on the array served_SS and the local information about the channel quality (i.e., r _m,n for all n). Since senders do not exchange information, they are not aware of each other's preferred resource (i.e., $q_m^i$ for all m) or channel quality (i.e., r _m',n for all m' and n). Moreover, under the rules of the proposed schemes, senders are not given any information about the resource budget r_budget, which is only stored in the BB. Senders are also queried in different orders for different prices, as mentioned earlier. Therefore, it is impossible for a sender to predict the decisions of other senders and the BB, let alone alter the result. Consequently, the probability that the resource price is p _i can be viewed as an unknown value 0≤ p _i ≤ 1, where $\sum _{i=1}^{I_{\mathsf{\text{max}}}}{P}_i=1$. Given that R _m,i (r) denotes the revenue of each sender m if it buys resources r under price p _i , the total expected value of the revenue is $\sum _{i=1}^{I_{\mathsf{\text{max}}}}{P}_i{R}_{m,i}\left(r\right)$. Therefore, irrespective of the value of p _i , the most effective strategy is to maximize R _m,i (r) for all i because other decisions would not yield revenues larger than $\sum _{i=1}^{I_{\mathsf{\text{max}}}}{P}_i\underset{r}{\mathsf{\text{max}}}\left(R_{m,i}\left(r\right)\right)$.

Next, we consider finding $\underset{r}{\mathsf{\text{max}}}\left(R_{m,i}\left(r\right)\right)$ under a given price p _i . When the resource claimed by m is 0, its profit is 0. It pays nothing and earns nothing because the sender does not receive the stream from other senders, so it does not serve any nodes. If r (i.e., the allocated resource) ≥ 0, then $R_{m,i}\left(r\right)=p_{\mathsf{\text{stream}}}\underset{\sum }{\overset{served\text{\_}SS\left[n\right]=0}{}}U\left(r-r_{m,n}\right)-r{p}_i$, where rp _i is the total price the sender has to pay the BB; while $p_{\mathsf{\text{stream}}}\underset{\sum }{\overset{served\text{\_}SS\left[n\right]=0}{}}U\left(r-r_{m,n}\right)$ is the income m receives from the SSs it serves. Therefore, under this dominant strategy, for all prices p _i , m's preferred amount of resource (i.e., the best strategy to use when requesting the resource)would be $q_m^i=\mathsf{\text{arg}}\underset{r}{\mathsf{\text{max}}}\left[\left(p_{stream}\underset{\sum }{\overset{served\text{\_}SS\left[n\right]=0}{}}U\left(r-r_{m,n}\right)-r{p}_i\right)\right]$, as shown in the second line of Figure 5.

4.3. Computational complexity

Theorem 4.3 The computational complexity of IBRC is polynomial.

Proof:

As shown in Figure 4, the main function of IBRC comprises two for loops and one do loop. The complexity of the first for loop is O(1) because I _max is a constant; while the complexity of the do loop is O(M) because it queries at least one sender in each round and thus executes M times at most. The complexity of the second for loop is also O(M) because the value of m ranges from 0 to M. Finally, the complexity of the pricing decision (i.e., i _set ← $\mathsf{\text{arg}}\underset{i}{\mathsf{\text{max}}}\left(p_i\times {\sum }_{m=1}^M{r}_m^i\right)$) is O(M) because, for each price, the BB has to sum the resource requirements of all the senders. The function query has to consider n = 0 to N, and the subsequent two for loops execute N and M times, respectively. Therefore, its overall complexity is O(N + N + M) ≅ O(N) because, in a relay network. The number of SSs should be much larger than the number of RSs. Combining all the loops and sub-functions based on the loop structure, the overall complexity of IBRC is O(M M N + M) = O(M²N), which is in polynomial time.

Note that although the worst-case complexity of IBRC is O(M²N), the actual overhead during computation is much lower and approximates O(MN). This is because, in each round of the first for loop in the main function, the algorithm picks one available sender to query. In a round where the sender m does not satisfy the conditions (i.e., D _m == 1 and asked_RS[m] == 0), only one simple judgment is made, so its complexity can be ignored. After the algorithm queries the selected sender, it exits the for loop and starts the next round of the do loop. Therefore, the combined complexity of the first for loop and the do loop approximates O(M), so the complexity of IBRC also approximates O(MN).

4.4. Truthfulness analysis

Under IBRC, the system must ensure that the transactions about the resource between the senders and the BB, as well as the transactions about the multicast stream between the senders and SSs, are undeniable and cannot be forged. This can be achieved by providing some group signature/cypher technologies, by making a contractual agreement in advance, or by using a third-party to monitor the transactions. For example, an SS has to pay the sender p_stream for the key to decode the multicast stream. If the sender not serve the SS after receiving p_stream, it will be reported and penalized. Similarly, since all senders inform the BB about their preferred resource at a certain price (i.e., $q_m^i$), the system has complete information about the senders' resource requirements under all prices. Hence, the system can penalize a sender if it does not pay for the allocated resource, or if the BB receives the payment and does not allocate the resource. On the other hand, the reply to query is based on each sender's incentive. In the first for loop in Figure 5, the sender m marks all the SSs that it serves (i.e., $q_m^i\ge r_{m,n}$) by letting served_SS_new[n] = 1, and leaves the remaining SSs unchanged (i.e., served_SS_new[n] = served_SS [n]). Similarly, it updates array D by marking all RSs that it serves as 1 in the second for loop. The array served_SS_new and D _new returned by m can only influence other senders that have not been queried. Since the BB queries those senders after allocating the resource to m, if m updates served_SS_new or D _new incorrectly, the altered behavior of senders queried afterwards cannot benefit m, or the SSs that m serves. Recall that senders are queried in a different order for each price so they cannot prevent each other from being served by providing false served_SS_new and D _new information. In other words, senders do not have any incentive to give false information; thus, the design of IBRC encourages honesty.

4.5. Signaling overhead

If a centralized approach is used to solve MHMM, the information about the channel quality between all nodes must be concentrated in one place (typically the BS) so that the algorithm can gain a complete picture of the network and calculate the outcome. Consequently, the channel quality of M + N nodes must be transmitted separately over the wireless medium. For M + N nodes, the number of channel conditions between each pair of nodes (i.e., r _i,j for all r _i,j , 1 ≤ i, j ≤ M + N and i ≠ j,) is O((M + N)². Under a traditional centralized allocation scheme, the RSs would have to report all of this information before a central node could allocate the resource. In contrast, the signaling overhead of IBRC is O(M(M + N)) because, for i = 1 to I_max, the algorithm only queries each sender once (i.e., by calling the function query). For each query, the sender returns the arrays served_SS_new and D _{m_new} , whose sizes are O(N) and O(M), respectively. Since I_max is a constant, the total signaling overhead of the function query is O(M(M + N). When the number of SSs (i.e., the value of N) is large, the difference between the signaling overhead of a centralized scheme and that of IBRC can be substantial.

5.1. Simulation settings

The settings of the simulations are as follows. To determine the resource required by each node, the distribution of the nodes must be generated beforehand. Therefore, we place the BS at the central coordinates (0,0) of the plane, and distribute the SSs randomly in a circle whose radius is 100. We then place the RSs in the area that yields the best relaying utility because the goal of RSs is to improve the transmission quality. When RSs are close to the BS, relaying does not improve the performance noticeably because the BS can serve nearby SSs directly. On the other hand, if RSs are too far from the BS, the channel quality between them and the BS deteriorates. Ideally, the RSs should be placed in the middle of the BS's coverage area. Therefore, in our simulations, we place the RSs randomly in a circle whose radius is between $\frac{100}{3}$ and $\frac{200}{3}$. Figure 6 shows the placement setting in the simulations. The wireless channel model of simulations is based on the two-ray ground propagation model without fading [28], which is the most popular model for simulating wireless networks. Then, the resource required to transmit the stream from node i to node j is $r_{i,j}={d_{i,j}}^a$.

To set the price, we let the cost of serving one SS, (i.e., p_stream), be normalized to 1. Hence, we let the maximal unit price be the ratio between the total number of SSs and the resource required to serve the most distant SS, (i.e., $p_{I_{\mathsf{\text{max}}}}=\frac{N\cdot p_{\mathsf{\text{stream}}}}{{100}^a}$). The rationale is that no SS will be ignored by all senders because the BS can at least consider serving all SSs if the maximal unit price is given. Next, we divide the price $p_{I_{\mathsf{\text{max}}}}$ into K parts and let P = [Δp, 2Δp, ..., K Δp], where $\Delta p=\frac{p_{I_{\mathsf{\text{max}}}}}{K}$. In some pilot simulations, we found that the granularity of Δp (i.e., the value of K) did not affect the performance of IBRC significantly, as long as K was not too small, (e.g., K < 10). Since a larger K may increase the computation time of the simulations, we let K = 20 in this study.

Based on the above settings, we conducted three simulations. The first assessed the performance of IBRC using different numbers of RSs and different resource budgets. In the second simulation, we observed the stability of the proposed algorithm; and in the third, we investigated the distribution of the benefits between the BB and RSs under different conditions.

5.2. Simulation I

We observe the impact of the resource budget and the number of RSs on the allocation performance. The attenuation factor a is set at 3, and r_budget is tuned from 0 to 100³ = 1,000,000 to cover the whole network. The number of RSs (i.e., M) is set at 0, 5, 10, 15, and 20. The results of each setting are averaged from 100 random node placements. Since MHMM is NP-hard, as proved in Theorem 3.1, and each setting is the average of 100 random node placements, finding the optimal solution is beyond the computing power of the equipment currently available. Therefore, in Figure 7a, we present the outcome of the simple shortest-path approach, which finds the shortest path for each SS independently, as mentioned in Section 1. We compare IBRC with the shortest path approach to demonstrate that the existence of RSs does not necessarily have a positive impact. The pure-BS approach (IBRCM = 0) means that no RSs are used in the resource allocation. In addition, in Figure 7b, we compare the performance of IBRC with an upper bound of the optimal solution to assess its efficiency.

The simulation results in Figure 7a show that, given the same resource budget, IBRC's performance (i.e., the number of SSs served) improves as M increases. This is because, under IBRC, the larger the number of RSs, the greater the possibility that they can utilize the resource to increase their profit, which makes the allocation more efficient. On the other hand, the simple shortest-path approach shows no obvious performance improvement compared to the pure-BS approach Moreover, as M increases and the senders of SSs become more diverse, the performance degrades further. This is because minimizing the resource required by each SS independently is not necessarily an efficient allocation strategy. If the multicast routes of all SS sare not considered together, the relaying operations of RSs do not always improve the performance.

Next we assess the maximal performance difference between IBRCand the upper bound of the optimum. Given that $r_m^{\mathsf{\text{min}}}$ represents the minimal resources required for each RSm to receive the stream from the BS (i.e., the resources required by the shortest path from the BS to RSm), the maximal possible resources each RS m acquires under budget r_budget can not be larger than $r_{\mathsf{\text{budget}}}-r_m^{\mathsf{\text{min}}}$. It follows that the performance of the optimal solution is upper-bounded by ${\sum }_{n=M+1}^{M+N}\mathsf{\text{min}}\left[1,{\sum }_{m=0}^{M}U\left(\left(r_{\mathsf{\text{budget}}}-r_m^{\mathsf{\text{min}}}\right)-r_{m,n}\right)\right]$. Therefore, IBRC's performance ratio to the optimum is never less than the ratio to this bound. In Figure 7b, which shows the ratio of IBRC, we observe two phenomena. First, IBRC is more efficient (i.e., the ratio approximates 100%) when the available resource is close to 0 or 100%. This is because, when the budget approximates the scarce or sufficient extreme, the number of possible allocations is limited. Second, under different numbers of RSs and resource budgets, the ratio is larger than 70% most of the time, and the lowest performance ratio is always larger than 60%. This trend evidences the efficiency of IBRC. Since we use the upper bound instead of the actual optimum solution, the actual ratio may be even higher.

5.3. Simulation II

To assess the stability of IBRC's allocation strategy, we define a category called sacrificed SSs, which are SSs served before a new SS joins and requests the stream, but they become unserved afterwards. This phenomenon occurs because an incoming SS may cause senders to make different service decisions and thus change the network topology. If a new user can interrupt the services provided to a large number of users, the proposed IBRC scheme would be impractical because the subscribed service would be unstable. Therefore, the number of sacrificed SSs should be kept to a minimum. Similar to Simulation I, we set a = 3, N = 100, and tune r_budget from 0 to 100³. After the allocation has been computed, a new SS is placed at random in the circle area. A new allocation is then generated and compared with the old one to calculate the number of sacrificed SSs. Again, the results of each setting are averaged over 100 random runs.

Figure 8 shows the trend of the sacrificed SSs. When the value of r_budget is moderate (between 600,000 and 800,000), the number of sacrificed SSs tends to be larger. It is also obvious that the number of sacrificed SSs increases with M. This occurs because, when there are more active RSs due to a larger resource budget, each SS may have more diverse senders; hence, the SSs are more likely to be affected as the topology changes. However, given different budgets and different numbers of RSs, the maximum number of sacrificed SSs is less than 0.35, which represents a very small proportion of both the served SSs and the total number of SSs (i.e., 0.35 over 100). In other words, one SS is sacrificed in about one-third of the cases. Therefore, even if other protection mechanisms are not used, IBRC may only interrupt a few served SSs and it continues to provide very stable services when a new subscriber joins. However, if necessary, the sacrifice of SSs can be prevented by strictly enforcing some call admission control constraints, e.g., a new SS can only be served if no existing SSs are sacrificed.

5.4. Simulation III

Finally, we investigate the profit distribution between the BB and the senders. The BB's profit (i.e., γ_BB) is the decided price multiplied by the total amount of the resource consumed at that price (i.e., $p_{i_{set}}{\sum }_{m=1}^M{r}_m^{i_{set}}$). Hence, the BB's share of the profit (i.e., the ratio between γ_BB and the total profit from served mobile users) is $\frac{{\gamma }_{\mathsf{\text{BB}}}}{N_{\mathsf{\text{served}}}{p}_{\mathsf{\text{stream}}}}$; and the average share of the senders (including the BS and the RSs) is $\frac{1-\frac{{\gamma }_{\mathsf{\text{BB}}}}{N_{\mathsf{\text{served}}}{p}_{\mathsf{\text{stream}}}}}{M+1}$, where N_served is the number of served SSs.

As shown in Figure 9a, the BB receives a higher proportion of the profit when M is large and r_budget is moderate. However, the results also show that even when the network comprises only one sender (i.e., the BS), the BB can still derive a stable proportion of the profit (about 50%). Meanwhile, the average profit of senders shown in Figure 9b is relatively stable as r_budget changes, but obviously declines as M increases. The results demonstrate that the distribution of the profit is a reasonable reflection of the contribution of each node. When there are more senders, the total resource requirement is higher at the same price. Therefore, the BB can set a higher price and derive a larger proportion of the total profit. A higher unit price reflects the scarcity of the resource and good resource utilization. On the other hand, since senders do not own the bandwidth and simply provide a relay service, the value that the bandwidth provides to the multicast service is constant. As a result, the senders' share of the profit should be stable as the budget r_budget changes. When there are more RSs and the relaying service is more prevalent, each sender has less utility in terms of relaying. In this scenario, a sender earns less revenue, so its average proportion of the profit is lower.