- Research
- Open Access
- Published:

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

*EURASIP Journal on Wireless Communications and Networking*
**volume 2012**, Article number: 188 (2012)

## Abstract

In this article, we propose an incentive-based resource allocation scheme for wireless relay networks. The aim of this article is to construct efficient multicast routes that serve as many users as possible with a given resource budget. First, we introduce a new resource allocation problem called Multi-Hop Multicast Maximization (MHMM). Then, we present our heuristic Incentive-Based Route Construction (IBRC) scheme, which enables each node to construct an efficient allocation separately and selfishly. We prove that the MHMM problem is NP-complete, and demonstrate that IBRC has polynomial-time complexity. Moreover, under the scheme, each node has an incentive to operate as designed. IBRC's signaling overhead is much lower than that of the conventional centralized approach, and the results of simulations demonstrate that IBRC can motivate relay nodes to provide efficient and stable resource allocations. The results also show that the revenue distribution among nodes is reasonable because it reflects the utility provided by each node. Multicast services deployed under IBRC are efficient and achieve a good performance, but only incur a low overhead.

## 1. Introduction

Modern wireless access networks, such as IEEE 802.16 and IEEE 802.11, provide broad coverage and achieve high transmission rates. They typically comprise two classes of nodes, namely, a Base Station (BS) and Subscriber Stations (SSs). The BS serves as a gateway to the wired network, while the SSs can be various kinds of mobile or static client devices. Recently, a new type of infrastructure node called a Relay Station (RS) has been discussed in the literature and standards. RSs themselves do not provide wired connections; instead, they wirelessly forward data upward and downward between the BS and SSs to improve the performance and coverage of the wireless network. The IEEE 802.16j standard [1] includes support for RSs in IEEE 802.16 networks; while a number of articles, such as [2–4], consider IEEE 802.11 multi-hop networks, which allow transit APs to relay packets for mobile users.

As the capacity of mobile devices continues to improve, an increasing number of multicast applications, such as wireless IPTV, Radio over IP, and Video conferencing, are being developed for mobile users. Recently developed technologies, like Wi-Fi and WiMAX, are excellent platforms that enable service carriers to provide multicast services wirelessly due to the platforms' high capacity, wide coverage range and the broadcast nature of the wireless medium. To adapt wireless transmissions to different channel conditions, most wireless technologies use adaptive modulation and coding (AMC) [5], which adapts modulation and coding methods dynamically based on the channel quality. When the channel quality is good, a faster coding scheme can be chosen; and when it is poor, a slower but more robust one should be used. Since the channel quality of wireless nodes varies, the appropriate coding scheme and the corresponding rate may be different for each node. Moreover, as the wireless resource is naturally scarce, the amount used by each multicast service should be limited in order to maintain the stability and fairness of the network. Clearly, it is impossible to provide all the services requested by users. Given the limited budget of a multicast stream, the system should service as many requests as possible so that the overall satisfaction of users can be maximized.

When a network only comprises a BS and SSs, multicasting over an AMC-supported network is a simple trade-off problem. The number of recipients can easily be maximized by giving all of the available resource to the BS. However, in a wireless relay network, the problem becomes much more complex and challenging because the RSs cannot serve any SS before receiving the stream from other senders. Therefore, the amount of the resource allocated to each sender must be decided, and the connectivity of the network must be considered. Figure 1 illustrates the complexity of the problem. The figure also shows a network with two RSs and two SSs; and the number on each link refers to the wireless resource required to successfully transmit a multicast stream. Typical unicast schemes use a simple greedy approach, which finds the route from the BS to each SS that consumes the least amount of the resource. Under this approach, SS1 and SS2 connect to the BS via RS1 and RS2, respectively. Due to the broadcast nature of wireless channel, the two RSs can receive the stream from the BS concurrently with resource 1, but the two SSs have to receive it from different RSs with resource 3; hence, the total resource consumed by this topology is 3 + 3 + 1 = 7. However, the required resource can be reduced to 5 if both SSs receive the stream from the BS directly. Given a certain amount of the budget, say 5, at most one SS can receive the stream in the first network configuration, but both SSs can be served in the second configuration. This example shows that if a multicast service is provided over a wireless relay network, the whole network topology should be considered, instead of minimizing the resource required by each node separately. A simple greedy approach may be feasible for unicast traffic, but it is not suitable for wireless multicast services. To resolve the problem, we try to maximize the total number of multicast recipients under a certain resource budget in multi-level wireless relay networks, where an RS can be the relay node for another RS. To the best of authors' knowledge, a resource allocation scheme capable of dealing with this issue has not been proposed in the literature.

The selfish behavior of RSs and the heavy signaling overhead incurred by information exchange make the problem even more challenging. In a wireless wide-area network, different organizations, such as companies, schools, restaurants, small business offices, individual residences, and hot spots, may set up proprietary RSs to improve the access quality for mobile device users. Local carriers may also want to set up RSs to implement forwarding services for better network coverage and access quality. Network carriers encourage the use of proprietary RSs because mobile users associated with such RSs can enjoy better channel quality. The performance of the SSs is not affected, since they can still access the network via the original relays. However, proprietary RSs usually belong to independent profit-oriented entities, so they are indeed selfish. In other words, they want to maximize their income and will only forward/relay packets for other nodes when the profit they make exceeds the cost of relaying. As the selfish behavior of RSs may result in low utility of the allocated resource, they should be encouraged to cooperate with other senders so that the performance of the whole network (i.e., the total number of multicast recipients) can be further improved. The signaling overhead compounds the multicast problem. To obtain a complete picture of the network, a centralized allocation scheme must monitor all the channel conditions between each sender-receiver pair, which results in a high signaling overhead for information exchange when the network scope is large. If a multicast resource allocation scheme could be implemented in a more distributed manner, where each independent node decides an operation without exchanging the channel information, the signaling overhead would be reduced substantially and the scalability of multicast services would be improved.

The above challenges call for a dedicated incentive-based low-overhead allocation scheme for multicast services over wireless relay networks. To this end, we define a maximization problem called Multi-Hop Multicast Maximization (MHMM) in wireless relay networks, where the RSs can act as relays for other RSs. Given the budget of a multicast service and the channel quality of all nodes, MHMM tries to maximize the number of recipients. We prove that MHMM is NP-complete. Since no existing work can resolve this problem effectively, we focus on wireless relay networks in which the BS and RSs are selfish, and propose a mechanism called Incentive-Based Route Construction (IBRC). In the proposed scheme, each sender decides the amount of the resource it requires and the service condition independently based on its own information and incentive. Therefore, the conflicting interests that arise when forming a purely centralized system can be avoided, and each sender's channel information does not have to be reported to a conventional centralized allocation scheme. Through analysis, we show that each agent (i.e., BS, RS, and SS) in the proposed mechanism will operate as designed because its income can be maximized. We also demonstrate the efficacy of IBRC via simulations. The results show that the scheme achieves a good performance and implements a stable allocation strategy.

Because all nodes operate independently and the amount of information exchanged between nodes is reduced, IBRC has a low signaling overhead and good scalability. Moreover, since IBRC is modeled in a very general way, it can be implemented indifferent kinds of wireless relay networks as long as AMC is supported. The mechanism can also handle unicast traffic by treating each flow as a multicast service that has only one recipient. Meanwhile, the low computational complexity and signaling overhead of IBRC mean that it can be executed in real-time or periodically to reflect time-varying channel conditions. Although IBRC considers the allocation of each session separately, given the budget of each stream, the scheme can construct the resource allocation strategies of several multicast services in a system. To the best of authors' knowledge, this is the first study that solves the multicast problem and yields all of the above advantages.

The remainder of the article is organized as follows. Section 2 contains a review of related studies. In Section 3, we model the system and analyze the difficulty of the problem. In Section 4, we introduce the proposed scheme, study the best strategy for each agent, and consider the scheme's complexity and performance. The simulation results are reported and discussed in Section 5. We then summarize our conclusions in Section 6.

## 2. Related study

In this section, we review some related studies on multicast in wireless relay networks, the selfish behavior of some agents, and the incentive mechanisms used to motivate those agents to cooperate with other nodes.

### 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. System and business models

In this section, we describe the system and business models for wireless relay networks. We also formally define the multicast recipient maximization problem and prove that it is NP-complete.

### 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*_{0}) 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*^{2}) 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*_{1}, *S*_{2}, ..., *e*_{
N
}}, where *S*_{
m
} ⊆ {*e*_{1}, *e*_{2}, ..., *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*_{1}, *m*_{2} ≤ *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*^{3}*N*) because, as mentioned in Section3.1, the complexity of finding ${D}_{m}\left(\Re \right)$ for all *m* is *O*(*M*^{2}), 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. Methods: IBRC

In this section, we discuss the proposed mechanism, called IBRC for MHMM, and show that it achieves good resource utilization. We analyze the mechanism's truthfulness and computational complexity, and compare the signaling overhead with that of the traditional centralized approach.

### 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*^{2}*N*), which is in polynomial time.

Note that although the worst-case complexity of IBRC is *O*(*M*^{2}*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*)^{2}. 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. Performance evaluation

In this section, we evaluate the performance of IBRC via simulations and demonstrate that it achieves good performance.

### 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^{3} = 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 (IBRC*M* = 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 RS*m* to receive the stream from the BS (i.e., the resources required by the shortest path from the BS to RS*m*), 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^{3}. 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.

## 6. Conclusion

In this article, we have investigated the multicast resource allocation problem in wireless relay networks. To the best of authors' knowledge, this issue has not been studied previously. We formulate the problem as MHMM and propose an economics-based algorithm called IBRC to resolve it. In the proposed scheme, each agent, including the BS, RS, and the BB, decides its best strategy based on the local information and its own incentive, so it can operate selfishly and independently. We show that, under IBRC, each agent has an incentive to operate honestly because it is the best way to obtain the maximum profit. Through analysis, we prove that MHMM is NP-complete, while IBRC has polynomial-time complexity. In addition, we show that IBRC's signaling overhead is significantly lower than that of the traditional centralized allocation scheme because the amount of information exchanged is reduced substantially. The simulations also demonstrate that IBRC allocates resources and utilizes RSs efficiently.

We also validate IBRC's performance through simulations. The results show that the larger the number RSs, the better will be the performance, which means that the scheme can utilize RSs to improve the allocation of bandwidth. Furthermore, we evaluate IBRC's operating stability and revenue distribution. In different scenarios, the allocation strategy is very stable, so existing users are rarely affected by a new user's request for bandwidth. Meanwhile, the revenue distribution between the senders (i.e., the BS and RSs) and the BB appears to be reasonable under different conditions, since each agent receives a fair and acceptable percentage of the profit based on the utility it provides. Our analysis and simulations show that IBRC is an efficient scheme that achieves a good performance, but only incurs a low signaling overhead. Thus, it can be adapted to different kinds of wireless relay networks in the real world. In the future, based on the findings reported in this study, we will consider the impact of users' mobility, as well as the Qo S requirements of different traffic types (e.g., elastic and inelastic ones).

## References

- 1.
802.16j Baseline Document: "Baseline Document for Draft Standard for Local and Metropolitan Area Networks,".

*IEEE 802.16j-06/026r2*2007. - 2.
Robinson J, Knightly E: A performance study of deployment factors in wireless mesh networks. In

*Proceedings of IEEE INFOCOM 2007*. Anchorage, Alaska, USA; 2007:2054-2062. - 3.
Camp J, Robinson J, Steger C, Knightly E: Measurement driven deployment of a two-tier urban mesh access network. In

*Proceedings of ACM MOBISYS 2006*. Uppsala, Sweden; 2006:96-109. - 4.
Gambiroza V, Sadeghi B, Knightly EW: End-to-end performance and fairness in multihop wireless backhaul networks. In

*Proceedings of ACM MOBICOM 2004*. Philadelphia PA; 2004:287-301. - 5.
Goldsmith AJ, Chua S-G: Adaptive coded modulation for fading channels.

*IEEE Trans Commun*1998, 46(5):595-602. 10.1109/26.668727 - 6.
Lee H, Cho D-H: Reliable multicast services using CDMA codes in IEEE 802.16 OFDMA system. In

*Proceedings of IEEE Vehicular Technology Conference 2005*. Dallas, USA; 2005:2349-2353. - 7.
She J, Hou F, Ho P, Xie L: IPTV over WiMAX: key success factors, challenges, and solutions.

*IEEE Commun Mag*2007, 87-93. - 8.
Zhao S, Xiong Z, Wang X: Optimal resource allocation for wireless video over CDMA networks.

*IEEE Trans Mob Comput*2005, 4(1):56-67. - 9.
Wieselthier JE, Nguyen GD,

*et al*.: On the construction of energy-efficient broadcast and multicast trees in wireless networks. In*Proceedings of IEEE INFOCOM 2000*. Tel-Aviv, Israel; 2000:585-594. - 10.
Egecioglu O, Gonzalez T: Minimum-energy broadcast in simple graphs with limited node power. In

*Proceedings of International Conference on Parallel and Distributed Computing and Systems (PDCS 2001)*. Anaheim, CA; 2001:334-338. - 11.
Li D, Jia X, Liu H: Energy efficient broadcast routing in static ad hoc wireless networks.

*IEEE Trans Mob Comput*2004, 3(2):144-151. 10.1109/TMC.2004.10 - 12.
Guo S, Yang O: A dynamic multicast tree reconstruction algorithm for minimum-energy multicasting in wireless ad hoc networks. In

*Proceedings of IEEE International Conference on Performance, Computing, and Communications, 2004*. Phoenix Arizona; 2004:634-642. - 13.
Buchegger S, Le Boudec J: Cooperative routing in mobile ad-hoc networks: current efforts against malice and selfishness. In

*Proc of Lecture Notes on Informatics, Mobile Internet Workshop, 2002*. Dortmund, Germany; 2002. - 14.
Buchegger S, Le Boudec JY: Performance analysis of the CONFIDANT protocol: cooperation of nodes-fairness in dynamic ad-hoc networks. In

*Proc of ACM Mobi Hoc*. Tokyo, Japan; 2002:226-236. - 15.
Michiardi P, Molva R: Core: a collaborative reputation mechanism to enforce node cooperation in mobile ad hoc networks. In

*Proc of IFIP CMS 2002*. Portoroz, Slovenia; 2002:107-121. - 16.
Resnick P, Kuwabara K, Zeckhauser R, Friedman E: Reputation systems.

*Commun ACM*2000, 43(12):45-48. 10.1145/355112.355122 - 17.
Marti S, Giuli T, Lai K, Baker M: Mitigating routing misbehavior in mobile ad hoc networks. In

*Proc of ACM MobiCom, 2000*. Boston, MA; 2000:255-265. - 18.
Buchegger S, Boudec J-YL: Nodes bearing grudges: towards routing security, fairness, and robustness in mobile ad hoc networks. In

*Proc of Euromicro PDP, 2002*. Canary Islands, Spain; 2002:403-410. - 19.
Zhong S, Yang Y, Chen J: Sprite: a simple, cheat-proof, credit-based system for mobile ad hoc networks. In

*Proc. of IEEE Infocom, 2003*. San Francisco, California; 2003:1987-1997. - 20.
Buttyan L, Hubaux J: Enforcing service availability in mobile adhoc WANs. In

*Proc of ACM MobiHoc, 2000*. Boston MA; 2000:87-96. - 21.
Jakobsson M, Hubaux J, Buttyan L: A micro-payment scheme encouraging collaboration in multi-hop cellular networks. In

*Proc of Financial Crypto, 2003*. Gosier Guadeloupe; 2003:15-33. - 22.
Anderegg L, Eidenbenz S: Ad hoc-VCG: a truthful and cost-efficient routing protocol for mobile ad hoc networks with selfish agents. In

*Proc of ACM Mobicom, 2003*. San Diego, CA; 2003:245-259. - 23.
Wang W, Li X-Y, Wang Y: Truthful multicast routing in selfish wireless networks". In

*Proceedings of MOBICOM*. Philadelphia, PA, USA; 2004:245-259. - 24.
Wei H-Y, Gilin RD: Incentive scheduling for cooperative relay in WWAN/WLAN two-hop-relay network. In

*Proceedings of WCNC 2005*. New Orleans, LA USA; 2005. - 25.
Lee J-F, Liao W, Chen MC: An incentive-based fairness mechanism for multi-hop wireless backhaul networks with selfish nodes.

*IEEE Trans Wirel Commun*2008, 7(2):697-704. - 26.
Hochbaum D: Approximating covering and packing problems: Set cover, vertex cover, independent set, and related problems. In

*"Approximation Algorithms for NP-hard Problems"*. Edited by: Hochbaum, D. PWS-Kent, Boston; 1997:94-143. - 27.
An Architecture for differentiated services

*IETF RFC 2475* - 28.
Rappaport TS:

*Wireless Communications: Principles and Practices*. Prentice-Hall, Englewood Cliffs, NJ; 1996.

## Author information

### Affiliations

### Corresponding author

## Additional information

### Competing interests

The authors declare that they have no competing interests.

## Authors’ original submitted files for images

Below are the links to the authors’ original submitted files for images.

## Rights and permissions

**Open Access** This article is distributed under the terms of the Creative Commons Attribution 2.0 International License (https://creativecommons.org/licenses/by/2.0), which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.

## About this article

### Cite this article

Kuo, W., Chang, C. An incentive-based multicast route construction scheme for recipient maximization in wireless relay networks.
*J Wireless Com Network* **2012, **188 (2012). https://doi.org/10.1186/1687-1499-2012-188

Received:

Accepted:

Published:

### Keywords

- multicast
- wireless relay networks
- resource allocation