Optimal Resource Allocation for Increasing Strictly
Concave Utility Functions in Wireless Networks
Tsern-Huei Lee, Senior Member, IEEE, Yu-Wen Huang, Student Member, IEEE, and Chien-Nan Chen
Abstract—Utility functions are widely used to model
user-perceived service quality. For elastic traffic, the utility function is often concave. An elastic allocation (EA) algorithm has recently been proposed to maximize the total utility obtained by users, assuming resource is infinitesimally divisible and queues are con-stantly backlogged. We found that the EA algorithm is not always optimal. In fact, the solution it obtains can be infeasible. In this paper, we present a modified EA algorithm that is guaranteed to find the optimal solution under the same assumptions. The result is generalized for a system where queues are generally backlogged. In a real system, there is normally a basic unit for resources. Therefore, we further extend the designs to such a system for both constantly backlogged and generally backlogged queues. To reduce computational complexity, we also propose suboptimal resource allocation algorithms. Simulations are conducted to eval-uate the proposed algorithms in terms of utility sum and execution time. Results show that our proposed algorithms perform better than previous works. Moreover, the performances of the proposed suboptimal algorithms are close to those of the optimal algorithms.
Index Terms—Elastic traffic, resource allocation, utility,
wire-less network.
I. INTRODUCTION
M
AXIMIZING system throughput and achieving fairness among users in a wireless network are, in general, conflicting goals [1]. As a compromise, utility functions are widely used to model user satisfaction, and the goal becomes to maximize the total utility obtained by users.It is reasonable to assume that utility function is increasing in the amount of allocated resources. In this paper, a function
f (x) is said to be increasing (or decreasing) if b > a implies f (b) > f (a) (respectively, f (b) < f (a)). In general, utility
functions adopted for different types of applications are likely to be different. For example, in [2] and [3], the sigmoid and step functions are used, respectively, as the utility functions of soft and hard quality-of-service (QoS) traffic flows. For elastic traffic, the utility function is often an increasing strictly concave function [3]–[6].
In [4], a necessary and sufficient condition to maximize the utility function was derived to achieve cross-layer optimization for orthogonal frequency-division-multiplexing-based wireless networks. The same authors presented efficient dynamic
sub-Manuscript received June 14, 2011; revised September 27, 2011; accepted December 27, 2011. Date of publication January 23, 2011; date of current version March 21, 2012. The review of this paper was coordinated by Prof. J. Tang.
The authors are with the Institute of Communication Engineering, National Chiao Tung University, Hsinchu 30010, Taiwan (e-mail: tlee@banyan.cm.nctu.edu.tw; vicent@banyan.cm.nctu.edu.tw; brian28914@ gmail.com).
Digital Object Identifier 10.1109/TVT.2012.2185719
carrier and adaptive power allocation algorithms in [5]. In [3], a similar necessary and sufficient condition was stated for a simpler system. Two types of traffic, namely, hard QoS and elastic traffic, were studied. Efficient algorithms were provided to find the near-optimal solution for hard QoS traffic and the optimal solution for elastic traffic. The elastic allocation (EA) algorithm presented in [3], which was designed to find the optimal solution for elastic traffic, is related to our work and will be reviewed in Section III. All the works presented in [3]–[5] assumed that queues are constantly backlogged and that resources are infinitesimally divisible.
In [6], the assumption of constantly backlogged queues is relaxed. In other words, queues are assumed to be generally backlogged such that the data buffered in a queue can be completely served if sufficient resource is allocated. The as-sumption of infinitesimally divisible resource remains intact. The resource allocation problem was formulated to maximize the total utility obtained by users subject to the constraints provided by Kleinrock’s conservation law [7], which fully captures the behavior of a general queueing system. Since one crucial parameter of Kleinrock’s conservation law is not easy to compute, the authors suggested to manage the resource by the famous packetized general processor sharing [8] or weighted fair queueing [9], with the weights determined by the Lagrangian multiplier method. In addition to the assumption of infinitesimally divisible resource, average data arrival rate and packet size of each user are required, which further limits the applicability of the work presented in [6]. For convenience, we call a resource allocation algorithm fluid flow based if it assumes that the resource is infinitesimally divisible.
In a real system, there is a basic unit for resource. Such a unit will be referred to as resource block in this paper. For example, in IEEE 802.16 WiMAX [10] and long-term evolution (LTE) [11], a resource block is normally constituted by several trans-mission symbols on one subchannel. The granularity can be selected to trade performance with complexity. To distinguish from fluid-flow-based schemes, an algorithm that allocates resource blocks is called a resource-block-based algorithm.
In [12], a resource-block-based algorithm called PF-MUX was proposed to achieve proportional fairness for orthogonal frequency-division multiple-access (OFDMA) systems. The concept of proportional fairness was introduced in [13], and according to [14], the utility function corresponding to pro-portional fairness is log(x), where x represents the average rate obtained by a user. It is not hard to see that log(x) is an increasing strictly concave function of x for all x > 0. The PF-MUX algorithm assumes queues are constantly backlogged and
performs resource allocation based on some heuristic. It will be briefly reviewed in Section III because we will compare its performance with those of our proposed resource-block-based algorithms.
The purpose of this paper is to present optimal fluid-flow-based and resource-block-fluid-flow-based resource allocation algorithms for increasing strictly concave utility functions. The queues can be constantly backlogged or generally backlogged. For a fluid-flow-based system where queues are constantly backlogged, we found that the EA algorithm presented in [3] does not obtain the optimal solution for some cases. In fact, the solution it obtains can be infeasible. A modified EA (MEA) algorithm is proposed. We show that the MEA algorithm guarantees to find an op-timal solution. We then generalize the results to a generally backlogged system. Given queue statuses, a necessary and suf-ficient condition for optimal resource allocation is developed. Moreover, an optimal resource allocation algorithm, called generalized EA (GEA), is designed based on the necessary and sufficient condition. Finally, we turn to consider resource-block-based systems, where queues are either constantly or generally backlogged. A necessary and sufficient condition for optimal resource allocation is stated for both constantly backlogged and generally backlogged systems. A straightfor-ward resource allocation algorithm, called sequential allocation (SA), which generates optimal solutions for both constantly backlogged and generally backlogged systems, is presented. To speed up resource allocation, a resource-block-based EA (RBEA) and a generalized RBEA (GRBEA) are proposed, re-spectively, for constantly backlogged and generally backlogged systems. To further reduce the computational complexities of RBEA and GRBEA, we propose suboptimal algorithms called MEA+SA and GEA+SA for constantly backlogged and generally backlogged systems, respectively. The basic idea of MEA+SA (or GEA+SA) is to perform MEA (respectively, GEA) to get a preliminary solution and then execute SA for the rest of resource blocks. Simulations are conducted to evaluate the performances of the proposed resource allocation algo-rithms for various sizes of resource block and user numbers. Results show that the performances of the proposed suboptimal algorithms are close to those of the optimal algorithms. More-over, our proposed algorithms perform better than previous works.
The rest of this paper is organized as follows. Problem formulation is described in Section II. In Section III, we review related works. Optimal fluid-flow- and resource-block-based resource allocation algorithms are presented in Sections IV and V, respectively. Simulation results are provided and discussed in Section VI. Finally, we draw our conclusion in Section VII.
II. PROBLEMFORMULATION
Consider the downlink transmission of a wireless network that consists of a base station (BS) and a group of users. Let Ω represent the set of users. When the BS needs to perform resource allocation, it is assumed that both queue and channel statuses of users are known. This is an acceptable assumption because the BS maintains the queues and channel statuses can be obtained through status report or estimation. For each user,
Fig. 1. Example of U (r) and Ui(r), where U (r) = 1− e(−r/1000),
(c1, c2, c3) = (0.8, 0.4, 0.2), and (Q1, Q2, Q3) = (3200, 2000, 1200).
an adaptive modulation and coding (AMC) scheme is adopted according to its channel status to maximize transmission rate while keeping the probability of transmission error under an acceptable threshold. For user i, let Qi and cidenote, respec-tively, the amount of data buffered in its queue (called queue i) and the channel quality parameter. In this paper, Qiis expressed in terms of required resource assuming that data are transmitted by the maximum achievable rate among the available AMC schemes, and ci is defined as the ratio of the adopted AMC scheme to the maximum achievable rate and, therefore, is in the range [0, 1]. Note that we have Qi=∞ if queue i is assumed to be constantly backlogged and 0≤ Qi≤ ∞ if it is assumed to be generally backlogged. The utility function is denoted by U (r), where r is the allocated resource, assuming that the adopted AMC scheme yields the maximum achievable rate. We assume that the utility function U (r) is an increasingly strictly concave function so that the marginal utility function, which is defined by u(r) = (U (r)/dr), exists for all r and satisfies
u(r) > 0 and u(r) = (du(r)/dr) < 0. Let Ui(r) and ui(r) represent, respectively, the utility and marginal utility functions for user i. We have
ui(r) = ci· ui(r), if r≤ Qcii 0, otherwise Ui(r) = r 0 ui(s)ds. (2)
It is obvious that Ui(r) is a concave utility function and strictly concave in the range [0, (Qi/ci)]. Examples of U (r) and Ui(r) are depicted in Fig. 1.
Given Qiand ci for all i∈ Ω, our objective is to maximize
i∈ΩUi(ri) subject to
i∈Ωri ≤ rtotal and ri≥ 0 for all i∈ Ω, where riand rtotalrepresent, respectively, the amount of resource allocated to user i and the total resource. A resource allocation π(Ω) ={ri|i ∈ Ω} is said to be feasible if it satis-fies i∈Ωri≤ rtotal and ri≥ 0 for all i ∈ Ω. Furthermore, π(Ω) ={ri|i ∈ Ω} is said to be an optimal resource alloca-tion if and only if (iff) 1) it is feasible, and 2) it holds that
i∈ΩUi(ri)≥
i∈ΩUi(ri) for any feasible resource alloca-tion π(Ω) ={ri|i ∈ Ω}. We assume that time is divided into
TABLE I LIST OFMAJORNOTATIONS
frames, and resource allocation is performed at the beginning of each frame.
The above formulation is applicable to resource allocation in OFDMA-based systems such as WiMAX and LTE. For better comprehensibility, major notations used in this paper are summarized in Table I.
III. RELATEDWORKS
In this section, we review the EA [3] and the PF-MUX algorithms [12].
A. EA Algorithm
The EA algorithm was designed for fluid-flow-based sys-tems, where queues are constantly backlogged. As stated in [3], a resource allocation π(Ω) ={ri|i ∈ Ω} is optimal if it is marginally fair and satisfiesi∈Ωri= rtotal. Here, marginal fairness means ui(ri) = uj(rj)≥ uk(rk) for all users i, j, and k belonging to Ω with ri> 0, rj > 0, and rk= 0. Based on this necessary and sufficient condition, the following EA algorithm was proposed in [3].
Algorithm 1: EA [3] begin
1) Derive the inverse marginal utility function of each user (i.e., u−1i (x), i∈ Ω).
2) Compute the aggregate inverse marginal utility function
u−1(x; Ω) = i∈Ωu−1i (x).
3) Find the aggregate marginal utility function u(r; Ω) by taking the inverse of u−1(x; Ω).
4) Determine the aggregate marginal utility with respect to
rtotal(i.e., u(rtotal; Ω)).
5) The EA πEA(Ω) ={r∗i|i ∈ Ω} is given by ri∗= u−1i u(rtotal; Ω) , if ui(0)≥ u(rtotal; Ω) 0, otherwise end
The basic idea of the EA algorithm is to first determine the aggregate marginal utility, i.e., the value x that satisfies
i∈Ωu−1i (x) = rtotalor u(rtotal; Ω), and then compute the share of resource for each user based on u(rtotal; Ω). Unfor-tunately, its solution is infeasible if there exists user i such that ui(0) < u(rtotal; Ω). The reason is as follows. The assumption that the utility function is increasing strictly concave implies both ui(r) and u−1i (x) are decreasing for all i∈ Ω. Consequently, it is true that u−1k (u(rtotal; Ω)) < 0 if uk(0) < u(rtotal; Ω). According to the operation of the EA algorithm, we have ui(u−1(rtotal; Ω)) = uj(u−1(rtotal; Ω)) (in particular, ui(u−1(rtotal; Ω)) = uj(u−1(rtotal; Ω)) for all i,
j∈Ω, andi∈Ωu−1i (u(rtotal; Ω)) = rtotal). Assume that user
k is the only one that satisfies uk(0) < u(rtotal; Ω). By sim-ply setting rk∗= 0 makes i∈Ωri∗=i∈Ωu−1i (u(rtotal; Ω))− u−1k (u(rtotal; Ω)) = rtotal− u−1k (u(rtotal; Ω)) >
rtotal, which is a contradiction to the constraint i∈Ωr∗i ≤ rtotal. The following Lemma 1 states a more general case. Proofs of all lemmas and theorems are provided in Appendix A.
Lemma 1: Assume that rtotal> 0 and Qi=∞ for all i ∈ Ω. Given the EA πEA(Ω) ={r∗i|i∈Ω}, it holds that
i∈Ωr∗i > rtotalif Λ= ∅, where Λ = {i|i ∈ Ω, ui(0) < u(rtotal; Ω)}.
B. PF-MUX Algorithm
In [12], an OFDMA system consisting of M subchannels is considered. Each subchannel comprises S subcarriers and is divided into T slots. The basic resource unit is equal to one slot on a subchannel. Queues are assumed to be constantly backlogged. The resource allocation problem was formulated in [12] as an optimization problem that maximizesi∈Ωlog Ri, where Ri is the average rate of user i. A heuristic algo-rithm called PF-MUX was proposed to allocate subchannels to users.
Assume that the PF-MUX algorithm is to allocate the T slots of subchannel m to users. All users are sorted according to
ρi,m= (ci,m/Ri), where ci,m denotes the channel quality pa-rameter for user i on subchannel m, and Rirepresents the past
average rate of user i. Let Ωa, a = 0, 1, 2, . . . , log2T contain the top 2a users in ρi,m. The PF-MUX algorithm allocates to every user in Ωa(T /2a) slots for the maximum a that satisfies the following: 1) The average transmission rate of the users in Ωais greater than or equal to that of users in Ωa−1, and 2) the increment of utility sum if subchannel m is allocated to users in Ωa is greater than or equal to that if it is allocated to users in Ωa−1. The process of subchannel allocation is performed for m = 1 to M .
IV. RESOURCEALLOCATION FOR
FLUID-FLOW-BASEDSYSTEMS
In this section, we present optimal resource allocation algo-rithms for fluid-flow-based systems. The cases of constantly backlogged queues and generally backlogged queues are stud-ied in sections A and B, respectively.
A. Constantly Backlogged Queues
As discussed in Section III, if Λ ={i|i ∈ Ω, ui(0) < u(rtotal; Ω)} = ∅, then πEA(Ω) ={r∗i|i ∈ Ω} is not a fea-sible allocation because the constrainti∈Ωr∗i ≤ rtotalis vi-olated. The remedy is to remove every user k∈ Λ out of Ω and repeatedly execute the EA algorithm until a feasible solu-tion is obtained. This algorithm, called MEA, is subsequently described.
Algorithm 2: MEA Data: Λ = Γ = Ω Result: rifor all i∈ Ω
begin
whileΛ= ∅ do
Perform Steps 1)-4) of the EA algorithm for user set Γ.
Let Λ ={i|i ∈ Γ, ui(0) < u(rtotal; Γ)} Γ = Γ− Λ
end
ri = u−1i (u(rtotal; Γ)) for all i∈ Γ.
ri = 0 for all i∈ Ω − Γ
end
A property regarding πEA(Ω) ={r∗i|i ∈ Ω} and πEA(Ω− Λ) ={si|i ∈ Ω − Λ} is stated in Lemma 2. Note that r∗iand si represent the amount of resource allocated to user i if the EA algorithm is performed for users in Ω and Ω− Λ, respectively. This property is useful in proving the optimality of the proposed MEA algorithm stated in Theorem 3.
Lemma 2: Assume that rtotal> 0 and Qi=∞ for all i∈ Ω. Given πEA(Ω) ={ri∗|i ∈ Ω}, Λ = {i|i ∈ Ω, ui(0) < u(rtotal; Ω)} = ∅, and πEA(Ω− Λ) = {si|i ∈ Ω − Λ}, it holds that ui(si) > ui(r∗i) > uk(0) for any i∈ Ω − Λ and k∈ Λ.
Theorem 3: Assume that rtotal> 0 and Qi=∞ for all i∈ Ω. The allocation πMEA(Ω) ={ri|i ∈ Ω} determined by
the MEA algorithm is marginally fair and satisfiesi∈Ωri= rtotaland, thus, is optimal.
Note that Lemma 2 implies si< ri∗for all i∈ Ω − Λ. As a result, it is possible that{i|i ∈ Ω − Λ, ui(0) < u(rtotal; Ω− Λ)} = ∅. Moreover, the resource allocated to the same user decreases iteration by iteration. Let Γ be the user set of a particular iteration and i∈ Γ, k ∈ Ω − Γ. Lemma 2 implies that ui(si) > uk(0) if user i is allocated resource si≥ 0 in the considered iteration.
It is interesting to analyze the time complexity of the MEA algorithm. In Appendix B, we provide the analysis of time complexities of all the algorithms proposed in this paper.
B. Generally Backlogged Queues
In this section, we consider a system where queues are generally backlogged. It is clear that ifi∈Ω(Qi/ci)≤ rtotal, then π(Ω) ={ri|ri= (Qi/ci), i∈ Ω} is an optimal alloca-tion. In fact, any feasible resource allocation π(Ω) ={ri|ri≥ (Qi/ci), i∈ Ω} is optimal. Assume that
i∈Ω(Qi/ci) > rtotal. Let Γ be a subset of Ω such that i∈ Γ iff Qi> 0. The set Γ can be partitioned into three disjoint subsets, namely, ΓZ, ΓP, and ΓA, such that user i is contained in ΓZ, ΓP, or ΓA iff ri= 0, 0 < ri< (Qi/ci), or ri= (Qi/ci), respectively. The definition of marginal fairness is generalized as follows.
Definition: A resource allocation π(Ω) ={ri|i ∈ Ω} is said to be generalized marginally fair if 1) ri= 0 if Qi= 0 and 2) for any user z∈ ΓZ, p, p∈ ΓP, and a∈ ΓA, it is true that
uz(rz)≤ up(rp) = up(rp)≤ ua(ra). (3) Theorem 4 states a necessary and sufficient condition for an optimal allocation.
Theorem 4: Assume that rtotal> 0, 0≤ Qi≤ ∞ for all i ∈ Ω and i∈Ω(Qi/ci) > rtotal. A feasible resource allocation π(Ω) ={ri|i ∈ Ω} is optimal iff it is generalized marginally fair and satisfies i∈Ωri= rtotal. Moreover, there is exactly one optimal resource allocation.
In the rest of this section, we present an optimal resource allocation algorithm, called GEA, which meets the necessary and sufficient condition stated in Theorem 4. The basic idea of GEA is to first place users to their appropriate subsets (ΓZ, ΓP, or ΓA) and then calculate their resource shares. To accomplish this, we set ri= 0 for all i∈ Γ, ΓZ = Γ, and ΓP = ΓA=∅ initially. There are three possibilities in each iteration: 1) A user is moved from ΓZto ΓP; 2) a user is moved from ΓPto ΓA; and 3) all users are in their appropriate subsets and the optimal so-lution is obtained. As an example, assume that in some iteration user j is moved from ΓZ to ΓP. For this event to happen, the conditions to be met are the following: 1)i∈ΓPu−1i (uj(0)) +
i∈ΓA(Qi/ci) < rtotal (not all users are in their appropriate
subsets); 2) uj(0) = maxi∈ΓZui(0) (no user other than user j
is moved from ΓZto ΓP); and 3) uj(0)≥ maxi∈ΓPui(Qi/ci)
(no user is moved from ΓP to ΓA). The conditions for other events to happen can be determined similarly. After all users are placed in the correct subsets, the solution can be obtained by
solving (3) andi∈Ωri= rtotal. To summarize, we repeatedly check if it holds that
i∈ΓP u−1i (u) + i∈ΓA Qi ci ≥ rtotal (4) where u = max(max i∈ΓZ ui(0), max i∈ΓP ui Qi ci . (5)
If not, user i∗, chosen according to the following equation, is moved from one set to another:
i∗= arg max i∈ΓZ∪ΓP max i∈ΓZ ui(0), max i∈ΓP ui Qi ci . (6)
All users are placed in their appropriate subsets if inequality (4) holds. Once inequality (4) holds, the solution can be ob-tained as follows. Set ri= 0 for all user i∈ ΓZ∪ (Ω − Γ), ri = u−1i (u(rtotal−
i∈ΓA(Qi/ci); ΓP)) for all user i∈
ΓP, and ri= (Qi/ci) for all user i∈ ΓA. The pseudocode of GEA is provided in the following.
Algorithm 3: GEA Data:
1) Γ ={i|Qi> 0, i∈ Ω} 2) ΓZ = Γ
3) ΓP = ΓA=∅
Result: rifor all i∈ Ω
begin ifi∈Ω(Qi/ci)≤ rtotalthen ri= (Qi/ci) for all i∈ Γ ΓA= Γ else while (1) do
u = max(maxi∈ΓZui(0), maxi∈ΓPui(Qi/ci)) ifi∈ΓPu−1i (u)+i∈ΓA(Qi/ci)≥rtotalthen
ri= 0 for all user i∈ ΓZ∪ (Ω − Γ) ri= u−1i (u(rtotal−
i∈ΓA(Qi/ci); ΓP))
for all user i∈ ΓP
(User i is moved from ΓP to ΓA if ri= (Qi/ci).)
ri= (Qi/ci) for all user i∈ ΓA
exit else
i∗ = arg maxi∈ΓZ∪ΓP
(maxi∈ΓZui(0), maxi∈ΓPui(Qi/ci)) ifi∗∈ ΓZthen ΓZ= ΓZ− {i∗} ΓP = ΓP∪ {i∗} else ΓP = ΓP− {i∗} ΓA= ΓA∪ {i∗} end end end end end
V. RESOURCEALLOCATION FOR
RESOURCE-BLOCK-BASEDSYSTEMS
In this section, we consider resource allocation for resource-block-based systems. Let B denote the size of a resource block. We assume that rtotalis divisible by B, and let xtotal= (rtotal/B) denote the total number of resource blocks. An addi-tional constraint, i.e., ri= xi· B for all i ∈ Ω, is added to the problem formulation. Here, xi and ri represent, respectively, the number of resource blocks and the amount of resource allocated to user i. Again, the cases of constantly backlogged queues and generally backlogged queues are considered sepa-rately in two different sections.
A. Constantly Backlogged Queues
Let
∆Ui[j] = Ui(j· B) − Ui((j− 1) · B) (7) be the utility increment of user i after receiving its jth resource block. Since the utility function is strictly concave, we have
Ui[j] > Ui[j + 1], 1≤ j ≤ xtotal− 1. The definition of mar-ginal fairness for resource-block-based systems is described as follows.
Definition: A resource allocation π(Ω) ={xi|i ∈ Ω} is said to be resource-block-based generalized marginally fair if, for any users i, m∈ Ω and xi> 0, it holds that ∆Ui[xi]≥ ∆Um[xm+ 1].
Theorem 5 states a necessary and sufficient condition for a resource-block-based allocation to be optimal for constantly backlogged queues.
Theorem 5: Assume that xtotal> 0 and Qi=∞ for all i ∈ Ω. A feasible resource-block-based allocation π(Ω) ={xi|i ∈ Ω} is optimal iff it is resource-block-based marginally fair and satisfiesi∈Ωxi= xtotal.
An optimal allocation algorithm called SA finds i∗= arg maxi∈Ω∆Ui[xi+ 1], allocates one resource block to user i∗, and updates xi∗ = xi∗+ 1. The process repeats until no
more resource block is available. Of course, the initial value of xiis set to zero for all i∈ Ω. It is clear that the SA algorithm obtains an optimal solution because the resource-block-based marginal fairness is maintained after each resource block is allocated.
It is possible to allocate more than one resource block in each iteration. The allocation algorithm works as follows. Again, the initial value is set to zero for all xi. If Ω ={i}, we simply set xi= xi+ xtotal. Assume that|Ω| > 1. A user is removed from Ω if it will not receive any more resource block. Let
j∗= arg min
j∈Ω∆Uj[xj+ 1] (8)
and define
µi[xi] = max{m ≥ 0|∆Ui[xi+ m]≥ ∆Uj∗[xj∗+ 1]} (9) for all i∈ Ω. To maintain resource-block-based marginal fair-ness, we allocate to user i xi+ µi[xi] resource blocks and to user j∗xj∗+1resource blocks. To calculate µi[xi], we define a function gi(x), for all x≥ 0, as
Fig. 2. Example of RBEA for U (r) = 1− e(−r/1000), xtotal= 3, B = 1000, and (c1, c2) = (0.7, 0.3). It is clear that gi(x) is a continuous and decreasing function
of x for all x≥ 0. As a result, gi−1(u), the inverse function of
gi(x), exists, and µi[xi] can be computed by
µi[xi] =
g−1i (∆Uj∗[xj∗+ 1])
− xi. (11)
Note that we need to check whether such an allocation is feasible. Ifi∈Ωµi[xi]≤ xtotal, then it is feasible, and there-fore, we update xi= xi+ µi[xi] for all i∈ Ω and xtotal=
xtotal−
i∈Ωµi[xi]. Otherwise, user j∗ will not receive any more resource block and thus is removed from Ω. This process repeats until xtotal= 0. We call the preceding algorithm RBEA and subsequently summarize its procedure.
Algorithm 4: RBEA
Data:
1) Γ = Ω
2) xi = 0 for all i∈ Γ
Result: xifor all i∈ Γ
begin
whilextotal> 0 do
if|Γ| > 1 then
j∗= arg minj∈Γ∆Uj[xj+ 1]
µi[xi] =gi−1(∆Uj∗[xj∗+1]) −xifor all i∈ Γ
ifi∈Γµi[xi]≤ xtotalthen
xi= xi+ µi[xi] for all i∈ Γ xtotal= xtotal− i∈Γµi[xi] else Γ = Γ− {j∗} end else xi= xi+ xtotal, i∈ Γ xtotal= 0 end end end
As an example, consider a system that consists of two users and xtotal= 3. As shown in Fig. 2, we have j∗= 2, µ1[x1] = 1, and µ1[x2] = 1 in iteration 1. Therefore, two resource blocks are allocated, one to each user. In iteration 2, we have j∗= 2,
µ1[x1] = 1, and µ1[x2] = 1 again. However, the remaining resource, which is only one block, is insufficient for allocation. Consequently, user 2 is removed from the user set, and user 1 will be allocated the remaining resource block in iteration 3.
It is not hard to see that RBEA always maintains the resource-block-based marginal fairness property and, thus, ob-tains an optimal solution. According to the simulation results presented in the next section, the execution time of the RBEA algorithm is smaller than that of the SA algorithm as long as the block size B is small, which is normally the case in a real system.
To further speed up resource allocation, one can use the MEA algorithm to find a preliminary solution πMEA(Ω) ={ri|i ∈ Ω}, take the floor function (ri/B) for all i ∈ Ω to get an initial feasible solution, and finally perform SA, starting from the initial feasible solution, to obtain a suboptimal solution. We will refer to such a solution as MEA+SA solution and compare it with the optimal solution in the next section.
B. Generally Backlogged Queues
For the case of generally backlogged queues, the definition of ui(r) [see equation (1)] implies ∆Ui[j] > ∆Ui[j + 1] if 1≤ j ≤ (Qi/ci) and ∆Ui[j] = 0 if j≥ (Qi/ci) + 1. Note that if δ =(Qi/B· ci) < (Qi/B· ci), then we have ∆Ui[δ + 1] = Ui(Qi/c1)− Ui(B· δ). Obviously, xi= (Qi/B· ci) for all i∈ Ω is an optimal allocation ifi∈Ω (Qi/B· ci) ≤ xtotal. Assume that i∈Ω (Qi/B· ci) > xtotal. The condi-tion stated in Theorem 5 for constantly backlogged queues is also a necessary and sufficient condition for an allocation to be optimal for generally backlogged queues. The proof is straightforward and, thus, omitted.
It is clear that SA can directly be applied to find an optimal allocation for generally backlogged queues because the resource-block-based marginal fairness is maintained
after each resource block is allocated. For the RBEA al-gorithm, slight modification in calculating µi[xi] is needed. Equation (11) is valid only if gi−1(∆Uj∗[xj∗+ 1]) −
xi≤ (Qi/B· ci) . In case gi−1(∆Uj∗[xj∗ + 1]) − xi> (Qi/B· ci) , we have µi[xi] = (Qi/B· ci) if ∆Uj∗[xj∗ +
1]≤ ∆Ui[ (Qi/B· ci) ] or µi[xi] =(Qi/B· ci) otherwise. The modified version is named GRBEA algorithm. Note that when performing GRBEA, we have to update the correspond-ing queue status after allocatcorrespond-ing resource block(s) to some user. The pseudocode for GRBEA is subsequently presented.
Algorithm 5: GRBEA
Data:
1) Γ ={i|Qi> 0, i∈ Ω} 2) xi= 0 for all i∈ Ω
Result: xifor all i∈ Γ
begin
ifi∈Ω (Qi/B· ci) ≤ xtotalthen
xi= (Qi/B· ci) for all i ∈ Γ
else
whilextotal> 0 and Γ= ∅ do
if|Γ| > 1 then
j∗= arg minj∈Γ∆Uj[xj+ 1]
for alli∈ Γ do ifg−1i (∆Uj∗[xj∗+1]) −xi≤(Qi/B·ci) then µi[xi] =g−1i (∆Uj∗[xj∗ + 1]) − xi else if∆Uj∗[xj∗+1]≤∆Ui[ (Qi/B· ci) ] then µi[xi] = (Qi/B· ci) else µi[xi] =(Qi/B· ci) end end end ifi∈Γµi[xi]≤ xtotalthen for alli∈ Γ do xi= xi+ µi[xi] ifQi≤ µi[xi]· B · cithen Qi= 0 Γ = Γ− {i} else Qi= Qi− µi[xi]· B · ci end end xtotal= xtotal− i∈Γµi[xi] else Γ = Γ− {j∗} end else ifQi≤ xtotal· B · cithen Qi= 0 Γ = Γ− {i} xtotal= xtotal− (Qi/B· ci) else Qi= Qi− xtotal· B · ci xtotal= 0 end end end end end
An example of GRBEA is shown in Fig. 3, where a system that consists of two users with xtotal= 3 is considered. In iteration 1, we have j∗= 2, µ1[x1] = 1 and µ2[x2] = 1. There-fore, two resource blocks are allocated: one to each user. In iteration 2, we have j∗= 2, µ1[x1] = 1, and µ2[x2] = 1. Note that, in this iteration, the utility increment of user 1 is limited by its queue occupancy. The remaining resource is not enough to allocate one resource block to each user. Consequently, user 1 is removed from the user set in this iteration, and user 2 will be allocated the remaining resource block in iteration 3.
It is clear that the resource-block-based marginal fairness is kept after each iteration. Therefore, the solution obtained by GRBEA is an optimal allocation. Again, according to the simulation results presented in the next section, the execution time of the GRBEA algorithm is smaller than that of SA as long as the block size B is small.
Similar to MEA+SA design, we can also derive a pre-liminary solution πGEA(Ω) ={ri|i ∈ Ω} based on the GEA algorithm. An initial feasible solution can then be calculated by taking(ri/B) for all i ∈ Ω. After updating the number of remaining resource blocks and queue statuses, one can perform SA to obtain a suboptimal solution. Such an algorithm will be referred to as GEA+SA.
VI. SIMULATIONRESULTS
In this section, we evaluate the performances of the pro-posed algorithms. Two types of increasing strictly concave utility functions are considered. The investigated system is first described, followed by two simulation scenarios. Queues are constantly backlogged and generally backlogged in Scenarios 1 and 2, respectively.
A. Investigated System
In the investigated system, there is a cell with one BS and several users. Users are uniformly distributed in a circular area of radius 1 km, and the BS is located at the center. We consider the downlink of an OFDMA-based IEEE 802.16 WiMAX wireless network that consists of M subchannels and is operated under the partial usage subchannel mode so that the subchannel qualities of a specific user are identical. Every subchannel comprises S subcarriers and is divided into T slots. As a result, we have rtotal= M· S · T . In the simulations, we set M = 30, S = 25, and T = 10, which imply rtotal= 7500. Signals are transmitted with power equal to 1 W, attenuated due to path loss with exponent equal to 3, faded according to Rayleigh fading model, and finally suffered interference and noise with their total average power equal to −98 dBm. The available AMC schemes, which are the same as those adopted
Fig. 3. Example of GRBEA for U (r) = 1− e(−r/1000), x
total= 3, B = 1000, (c1, c2) = (0.7, 0.3), and (Q1, Q2) = (1050, 750). TABLE II
ADOPTEDMODULATION ANDCODINGSCHEMES[15]
in [15], are shown in Table II. Which AMC scheme is used depends on the receiver signal-to-interference-plus-noise ratio. Simulations are performed for 10, 20, and 30 users. For a resource-block-based system, the size of a resource block is 25 or 250, which correspond to one slot or one subchannel (10 slots), respectively. Simulations are performed using Matlab for 10 000 times on a computer equipped with an Intel Core 2 Q8200 CPU operated at 2.33 GHz with 3 GB of RAM.
B. Scenario 1
In Scenario 1, user queues are assumed to be constantly backlogged. The utility function of user i is Ui(r) = 1− e(−r·ci·cmax/1000), where c
idenotes the channel quality of user i, and cmax represents the maximum achievable rate of the adopted AMC schemes. The utility sum and average execution time of the proposed MEA, SA, RBEA, and MEA+SA are shown in Tables III and IV, respectively. As one can see, for each proposed algorithm, the utility sum increases as the number of users increases. This is because of user diversity. However, the execution time increases as well. Both utility sum and execution time decrease as the resource block size increases. For B = 25, SA spends more time than RBEA to obtain the solution. The reason is that RBEA allocates more than one resource block in each iteration, whereas SA allocates only one. On the contrary, SA is faster than RBEA for B = 250. This is because RBEA is more complicated than SA and for
B = 250, the number of resource blocks is only 30, which
TABLE III
UTILITYSUM OFMEAANDRESOURCE-BLOCK-BASED ALLOCATIONALGORITHMS
TABLE IV
EXECUTIONTIME OFMEAANDRESOURCE-BLOCK-BASED ALLOCATIONALGORITHMS
limits the advantage of allocating more than one resource block in an iteration. An interesting observation is that if the user number is fixed, the execution time of MEA+SA is almost in-dependent of resource block size. The reason is that, after taking the floor function, the number of remaining resource blocks is a random variable whose value falls in {0, 1, 2, . . . , |Ω| − 1}, and the results were averaged over 10 000 simulations. Based on simulation results, we conclude that, for small resource blocks, for example, B = 25, MEA+SA should be the best choice because it requires 83% and 61% less execution time as compared with SA and RBEA, respectively, while sacrificing very little utility sum (which is 1× 10−5or 6× 10−4%).
TABLE V
UTILITYSUM OFGEAANDRESOURCE-BLOCK-BASED ALLOCATIONALGORITHMS
C. Scenario 2
In Scenario 2, user queues are assumed to be generally backlogged. AnON–OFFmodel is adopted to describe the traffic arrival process for each user. The lengths ofONandOFFperiods are governed by exponential distribution with means equal to 0.01 and 0.03 s, respectively. During the ON period, data arrive at a rate uniformly chosen from 1 to 5 Mb/s and are encapsulated into packets of size equal to 1500 B. The utility function of user i is selected as Ui(r) = log(Ri[n]), where Ri[n] denotes the average throughput of user i up to frame n. In other words, we study the capability of the proposed algorithms to achieve proportional fairness. In our experiments, Ri[n] is updated by Ri[n] = 1−w1 Ri[n− 1] +r·cw·M·Ti·cmax, if Qi > 0 Ri[n− 1], otherwise (12)
where w, which is a weighting factor, is a design parameter. We set w = 5 in the experiments.
Simulations are performed for five resource allocation al-gorithms, i.e., GEA, SA, GEA+SA, GRBEA, and PF-MUX. For fair comparison, the PF-MUX algorithm is modified to consider queue statuses. When subchannel m is to be allocated to users in Ωa, it is only partially allocated if the total resource requests of users in Ωais smaller than T . The remaining part of subchannel m can be allocated to other users.
The utility sum and average execution time are shown in Tables V and VI, respectively. Again, the effect of user diversity yields a larger utility sum as the number of users increases, and there is tradeoff between resource block size and execution time. Moreover, the execution time of GEA+SA is almost independent of resource block size if user number is fixed. According to simulation results, PF-MUX requires the least execution time. However, its utility sum is the smallest, as compared with those of GEA, GEA+SA, and GRBEA. The difference increases as the number of users increases. For
|Ω| = 30, the difference is about 19%. The reason is that when
the number of users is small, the total resource of a frame is usually large enough to completely serve all data buffered in the queues. Consequently, the solutions obtained by all the studied algorithms are identical for most of the time. On the other hand, when the number of users becomes large, there are usually some data left in the queues at the end of every frame. As a
TABLE VI
EXECUTIONTIME OFGEAANDRESOURCE-BLOCK-BASED ALLOCATIONALGORITHMS
result, the suboptimal solutions are different from the optimal ones. In particular, the solution obtained by PF-MUX can be far from being optimal. For B = 25 and |Ω| = 10, SA, GRBEA, and GEA+SA yield about the same utility sum. However, GEA+SA requires an execution time that is 79% and 28% less than those of SA and GRBEA, respectively. Therefore, we conclude that GEA+SA should be the best choice for a system when resource block size and number of users are small. For a system with large resource block sizes, for example, B = 250, the execution times of SA and GRBEA can drop dramatically, whereas that of GEA only changes slightly. Therefore, we suggest using either SA or GRBEA as the resource allocation algorithm for such a system. As in Scenario 1, SA is faster than GRBEA for B = 250.
VII. CONCLUSION
In this paper, we have presented optimal resource allocation algorithms that maximize utility sum for wireless networks. The resource is either infinitesimally divisible or has a basic unit and queues can be either constantly backlogged or gener-ally backlogged. Numerical results show that one can combine the optimal algorithm designed for fluid-flow-based systems with SA to quickly obtain a suboptimal solution for a resource-block-based system with small block sizes. The performance of such a simple hybrid algorithm is close to that of the optimal algorithm. For large block sizes, which tend to decrease the utility sum and thus may not be a good design, one can adopt either SA or RBEA to do resource allocation. An interesting further research topic is to extend the results to general utility functions.
APPENDIXA
PROOFS OFLEMMAS1AND2ANDTHEOREMS3–6
Proof of Lemma 1: According to the operation of the
EA algorithm, we have rtotal=i∈Ωu−1i (uΣ(rtotal; Ω))=
i∈Ω−Λu−1i (uΣ(rtotal; Ω))+
k∈Λu−1k (uΣ(rtotal; Ω)). Since u−1k (x) is decreasing, it holds that u−1k (uΣ(rtotal; Ω) < 0 if k∈ Λ, which implies, when Λ = ∅, i∈Ωr∗i = i∈Ω−Λu−1i (uΣ(rtotal; Ω)) > i∈Ω−Λu−1i (uΣ(rtotal; Ω)) + i∈Λu−1i (uΣ(rtotal; Ω)) =
i∈Ωu−1i (uΣ(rtotal; Ω)) = rtotal. This completes the proof of Lemma 1.
Proof of Lemma 2: Assume that i∈ Ω − Λ and k ∈ Λ.
According to the operation of the EA algorithm, we have
ui(r∗i) = uk(u−1k (uΣ(rtotal; Ω))) = uΣ(rtotal; Ω), where u−1k × (uΣ(rtotal; Ω)) < 0. Since the marginal utility function is decreasing, it holds that uk(0) < uk(u−1k (uΣ(rtotal; Ω))) = ui(r∗i). It is not hard to see that, if we reduce the user set from Ω to Ω− Λ and perform the EA algorithm with total resource
i∈Ω−Λr∗i, then the aggregate marginal utility is also equal to uΣ(rtotal; Ω). Therefore, we have r∗i = u−1i (uΣ(
i∈Ω−Λr∗i; Ω− Λ)) or ui(ri∗) = uΣ(
i∈Ω−Λr∗i; Ω−Λ) for all i ∈ Ω−Λ. The fact that u−1i (x) is decreasing for all i∈ Ω implies
i∈Ω−Λu−1i (x) is decreasing, which in turn implies uΣ(r; Ω− Λ), the inverse of i∈Ω−Λu−1i (x) is decreasing. Therefore, we have ui(si) = uΣ(rtotal; Ω− Λ) > uΣ(
i∈Ω−Λr∗i; Ω− Λ) = ui(ri∗), because
i∈Ω−Λr∗i > rtotal, according to
Lemma 1.
Proof of Theorem 3: Let πMEA={ri|i ∈ Ω} be the al-location determined by the MEA algorithm. We need to prove that πMEA(Ω) is marginally fair and satisfiesi∈Ωri= rtotal. Assume that the MEA algorithm is executed for N iterations to obtain the solution πMEA. Let ΓN be the user set in the N th iteration. Since the MEA algorithm ends at the N th
iteration, it holds that ri ≥ 0 for all i ∈ ΓN and
i∈Ωri= rtotal. Moreover, it is true that ri= u−1i (uΣ(rtotal; ΓN)) and ui(ri) = uΣ(rtotal; ΓN) for all i∈ ΓN. Note that it is possible to have ri= 0 for some i∈ ΓN. For any k∈ Ω − ΓN, we have uΣ(rtotal; ΓN) > uk(0), according to Lemma 2. Therefore, πMEA={ri|i ∈ Ω} is marginally fair and satisfies
i∈Ωri= rtotal and, thus, is optimal. This completes the proof of
Theorem 3.
Proof of Theorem 4: Let π ={ri|i ∈ Ω} be an allocation that is generalized marginally fair and satisfies i∈Ωri= rtotal. We will prove π is the only optimal solution by showing that the utility sum obtained by π is greater than the utility sum obtained by any feasible allocation different from π.
Let Γ ={i|i∈Ω, Qi> 0}, ΓZ={i|ri= 0, i∈Γ}, ΓP={i|0< ri< (Qi/ci), i∈Γ}, and ΓA={i|ri= (Qi/ci), i∈Γ}. Consider any feasible allocation π={ri|i ∈ Ω} that is different from π. It is clear that, if ri> 0 for user i with Qi= 0, then the utility sum can be improved by shifting the resource allocated to user
i to user j with rj < (Qj/cj). Similarly, if
i∈Ωri< rtotal, then the utility sum can be improved by allocating the remaining resource to user k with rk < (Qk/ck). Therefore, we assume that ri= 0 if Qi= 0 and
i∈Ωri= rtotal. Let E and
F be two sets such that user i is in set E or set F iff ri> rior ri< ri, respectively. We have E⊆ ΓP∪ ΓA, F ⊆ ΓP ∪ ΓZ, and
i∈E(ri−ri) =
i∈F(ri−ri). According to (3), for any user i∈E and j ∈F , it holds that ui(ri)≥uj(rj). Let uE,min= mini∈Eui(ri). We have
i∈ΩUi(ri)− i∈ΩUi(ri) = i∈EUi(ri)− i∈EUi(ri)−( j∈FUj(rj)− j∈FUj(rj)) = i∈E ri ri ui(r)dr − j∈F rj rj uj(r) dr > i∈Eui(ri)· (ri− ri)− j∈Fuj(rj) · (rj− rj) ≥ uE,min (i∈E(ri−ri)−
j∈F(rj − rj)) = 0. Note that the first inequality in the preceding derivation is true because ui(x) is a decreasing function of x, and both sets E and F are nonempty. As a result, π, if it exists, is the unique optimal resource allocation.
Conversely, let π ={ri|i ∈ Ω} be an optimal alloca-tion. Note that optimal solution exists because there are obviously feasible solutions. Let Γ ={i|i ∈ Ω, Qi> 0}, ΓZ={i|ri= 0, i∈ Γ}, ΓP ={i|0 < ri< (Qi/ci), i∈ Γ}, and ΓA={i|ri= (Qi/ci), i∈ Γ}. Since
i∈Ω(Qi/ci) > rtotal, it must hold that i∈Ωri = rtotal and ri= 0 if Qi= 0. Assume that ΓP =∅. In other words, there ex-ists Ψ⊂ Ω such that Ψ = Ω, ri= (Qi/ci) for all i∈ Ψ, and i∈Ψri= rtotal. It is true that ui(ri)≤ uj(rj) for any users i∈ Ω − Ψ and j ∈ Ψ. Otherwise, if ui(ri) > uj(rj) for some i∈ Ω − Ψ and j ∈ Ψ, then the utility sum of π={rk|k ∈ Ω} with ri = ri+ δ, rj= rj− δ, 0 < δ < min((Qi/ci), u−1i (uΣ(rj;{i, j})), rj), and rk= rkfor all k∈ Ω− {i, j}, is greater than that of π, which is a contradiction to the assumption that π is an optimal allocation. (Note that δ =
u−1i (uΣ(rj;{i, j})) makes ui(ri) = uj(rj).) Therefore, π = {ri|i ∈ Ω} is generalized marginally fair if ΓP =∅.
Consider the case ΓP = ∅. We claim that ui(ri) = uj(rj) for all i, j∈ ΓP. Suppose that the claim is false, i.e., there exist i, j ∈ ΓP such that ui(ri) > uj(rj). In this case, the utility sum of π={rk|k ∈ Ω} with ri = ri+ δ, rj= rj− δ, 0 < δ < min((Qi/ci)− ri, u−1i (uΣ(ri+ rj;{i, j})) − ri, rj), and rk = rk for all k∈ Ω − {i, j} is greater than that of π, which is a contradiction to the optimality assumption of
π. Therefore, the claim is true. Assume that k∈ ΓZ. It must hold that uk(0)≤ ui(ri) for all i∈ ΓP. Otherwise, if uk(0) > ui(ri) for some i∈ ΓP, then the utility sum of π={rj|j ∈ Ω} with rk = rk+ δ, ri = ri− δ, 0 < δ < min((Qk/ck), u−1k (uΣ(rk+ ri;{i, k})), ri) and rj= rj for all j∈ Ω − {i, k} is greater than that of π, which is a contradiction to the optimality assumption of π again. Fi-nally, assume that k∈ ΓA. We have uk(rk)≥ ui(ri) for all i∈ ΓP. Otherwise, if uk(rk) < ui(ri) for some i∈ ΓP, then the utility sum of π={rj|j ∈ Ω} with ri= ri+ δ, rk= rk− δ, 0 < δ < min((Qi/ci)− ri, u−1i (uΣ(ri+ rk;{i, k})) − ri, rk), and rj= rj for all j ∈ Ω − {i, k} is greater than that of π, which is a contradiction once again. Therefore, we conclude that π ={ri|i ∈ Ω} is generalized marginally fair. This completes the proof of Theorem 4.
Proof of Theorem 5: Let π(Ω) ={xi|i ∈ Ω} be an opti-mal resource-block-based allocation. Since the utility function is increasing, it must hold thati∈Ωxi= xtotal. Assume that π(Ω) is not (resource-block-based) marginally fair, meaning
that there exists i and j such that xi> 0 and ∆Ui[xi] < ∆Ui[xj+ 1]. As a result, the allocation π(Ω) ={xi|i ∈ Ω}, where xi= xi− 1, xj= xj+ 1, and xk= xk if k= i or j gives larger total utility than π(Ω), which is a con-tradiction. Therefore, π(Ω) must be marginally fair. Con-versely, assume that π(Ω) ={xi|i ∈ Ω} is marginally fair with
i∈Ωxi= xtotal. Let α = min{∆Ui[xi]|xi> 0, i∈ Ω} and β = max{∆Uj[xj+ 1]|j ∈ Ω}. According to the definition of marginal fairness, we have α≥ β. Let π(Ω) ={xi|i ∈ Ω} be any other feasible allocation. Define two sets E and F such that E ={i|xi > xi, i∈ Ω} and F = {i|xi< xi, i∈ Ω}. We have i∈E(xi− xi) = i∈F(xi− xi). Let d = i∈E(xi− xi). It is true that i∈ΩUi(xi· B) − i∈ΩUi(xi· B) = i∈E∆Ui[xi]−
i∈F∆Ui[xi]≥ d(α − β) ≥ 0. Therefore, π(Ω) is optimal. This completes the proof of Theorem 5.
TABLE VII
TIMECOMPLEXITIES OF THEPROPOSEDRESOURCEALLOCATIONALGORITHMS
APPENDIXB
ANALYSIS OFTIMECOMPLEXITIES OF THE
PROPOSEDALGORITHMS
As analyzed in [3], the time complexity of the EA algorithm is O(|Ω|). Consequently, the time complexity of our proposed MEA algorithm is O(|Ω|2) because, in the worst case, users are removed one by one until one is left to be allocated with the total resource.
For the GEA algorithm, the maximum number of iterations needed is 2· |Ω| − 1, which happens when all users are moved (one by one) from ΓZ to ΓP, and |Ω| − 1 users are further moved from ΓPto ΓA. The computational complexity to move a user from ΓZto ΓPis O(|Ω|), while that to move a user from ΓP to ΓAis O(|Ω| − i) if |ΓP| = |Ω| − i. Therefore, the time complexity of GEA is O(|Ω|2).
Consider the three algorithms designed for resource-block-based systems with constantly backlogged queues, namely, SA, RBEA, and MEA+SA. Recall that, in SA, one resource block is allocated in each iteration. As a result, the time complexity of SA is O(xtotal· |Ω|) because the time complexity of each iteration is O(|Ω|). For the RBEA algorithm, define Si as its state when |Γ| = i. In the worst case, we have Γ = Ω initially, and the RBEA algorithm visits all states Si, i = |Ω|, |Ω| − 1, . . . , 1. Moreover, when resource blocks are to be
allocated to some user, only one is allocated. In other words, if resource blocks are allocated in state Si, then exactly i resource blocks are allocated. The computational complexity to allocate
i resource blocks in state Si is O(i). Since there are xtotal resource blocks, the computational complexity to allocate all the resource blocks to users is O(xtotal). According to the RBEA algorithm, the computational complexity to switch from state Si to state Si−1 is O(i). Therefore, the time complexity of RBEA is O(xtotal+|Ω|2). For the MEA+SA algorithm, let πMEA(Ω) ={ri|i ∈ Ω} denote the solution obtained by the MEA algorithm and{xi|i ∈ Ω} represent the preliminary solution, where xi=(ri/B) for all i ∈ Ω. Recall that the time complexity of the MEA algorithm is O(|Ω|2). Since
i∈Ωri= rtotal, we have xtotal−
i∈Ωxi≤ |Ω| − 1. As a consequence, there are at most|Ω| − 1 resource blocks to be allocated by the SA algorithm, which incurs a time complexity of O(|Ω|2). Therefore, the time complexity of the MEA+SA algorithm is O(|Ω|2).
Finally, consider GRBEA and MEA+SA, which are the two algorithms designed for resource-block-based systems with generally backlogged queues. For GRBEA, the maximum num-ber of iterations needed is the same as that required by RBEA. As a consequence, the time complexity of GRBEA is the same as that of RBEA. Similarly, the time complexity of GEA+SA is the same as that of MEA+SA. Table VII summarizes the time complexities of the proposed algorithms.
REFERENCES
[1] D. Angelini and M. Zorzi, “On the throughput and fairness perfor-mance of heterogeneous downlink packet traffic in a locally centralized CDMA/TDD system,” in Proc. IEEE VTC-Fall, 2002, pp. 510–514. [2] W. H. Kuo and W. Liao, “Utility-based radio resource allocation for QoS
traffic in wireless networks,” IEEE Trans. Wireless Commun., vol. 7, no. 7, pp. 2714–2722, Jul. 2008.
[3] W. H. Kuo and W. Liao, “Utility-based resource allocation in wireless networks,” IEEE Trans. Wireless Commun., vol. 6, no. 10, pp. 3600–3606, Oct. 2007.
[4] G. Song and Y. Li, “Cross layer optimization for OFDM wire-less networks—Part I: Theoretical frame work,” IEEE Trans. Wirewire-less
Commun., vol. 4, no. 2, pp. 614–624, Mar. 2005.
[5] G. Song and Y. Li, “Cross layer optimization for OFDM wire-less networks—Part II: Algorithm development,” IEEE Trans. Wirewire-less
Commun., vol. 4, no. 2, pp. 625–634, Mar. 2005.
[6] Z. Jiang, Y. Ge, and Y. Li, “Max-utility wireless resource management for best-effort traffic,” IEEE Trans. Wireless Commun., vol. 4, no. 1, pp. 100–111, Jan. 2005.
[7] L. Kleinrock, Queueing Systems Vol 2: Computer Applications. New York: Wiley, 1975.
[8] A. K. Parekh and R. G. Gallager, “A generalized processor sharing ap-proach to flow control in integrated services networks—The single node case,” IEEE/ACM Trans. Netw., vol. 1, no. 3, pp. 344–357, Jun. 1993. [9] A. Demers, S. Kesha, and S. Shenker, “Analysis and simulation of a fair
queueing algorithm,” J. Internetw. Res. Exper., vol. 1, no. 1, pp. 3–26, Sep. 1990.
[10] IEEE Standard for Local and Metropolitan area Networks—Part 16: Air Interface for Fixed Broadband Wireless Access Systems, IEEE Std. 802.16-2009, May 2009.
[11] E. Dahlman, S. Parkvall, J. Sköld, and P. Beming, 3G HSPA and LTE for
Mobile Broadband. New York: Academic, 2007.
[12] M. Kaneko, P. Popovski, and J. Dahl, “Proportional fairness in multi-carrier system with multi-slot frames: Upper bound and user multiplexing algorithms,” IEEE Trans. Wireless Commun., vol. 7, no. 1, pp. 22–26, Jan. 2008.
[13] F. P. Kelly, A. K. Maulloo, and D. K. H. Tan, “Rate control in commu-nication networks: Shadow prices, proportional fairness and stability,”
J. Oper. Res. Soc., vol. 49, pp. 237–252, Apr. 1998.
[14] H. Kim and Y. Han, “A proportional fair scheduling for multicarrier transmission systems,” IEEE Commun. Lett., vol. 9, no. 3, pp. 210–212, Mar. 2005.
[15] X. Zhu, J. Huo, C. Xu, and W. Ding, “QoS-guaranteed scheduling and resource allocation algorithm for IEEE 802.16 OFDMA system,” in Proc.
IEEE ICC, May 2008, pp. 3463–3468.
Tsern-Huei Lee (S’86–M’87–SM’98) received the
B.S. degree in electrical engineering from National Taiwan University, Taipei, Taiwan, in 1981, the M.S. degree in electrical engineering from the University of California, Santa Barbara, in 1983, and the Ph.D. degree in electrical engineering from the University of Southern California, Los Angeles, in 1987.
Since 1987, he has been a member of the faculty of the National Chiao Tung University, Hsinchu, Taiwan, where he is a Professor with the Department of Electrical Engineering. Over the past few years, he served as a Consultant to various companies to develop large-scale quality-of-service-enabled frame-based switches/routers, integrated access devices, and unified threat management Internet appliances. His current research interests are in communication protocols, broadband switching systems, traffic manage-ment, wireless communications, and network security.
Dr. Lee received an Outstanding Paper Award from the Institute of Chinese Engineers in 1991.
Yu-Wen Huang (S’07) was born in Gangshan
Dis-trict, Kaohsiung City, Taiwan, in 1982. He received the B.S. and M.S. degrees in communication engi-neering in 2004 and 2006, respectively, from the National Chiao Tung University, Hsinchu, Taiwan, where he currently working toward the Ph.D. degree. His current research interests include resource allocation, power management, and communication protocols in wireless networks.
Chien-Nan Chen received the B.S. degree in
com-munication engineering from the National Central University, Taoyuan, Taiwan, in 2009 and the M.S. degree in communication engineering in Chiao Tung University, Hsinchu, Taiwan, in 2011.
He is currently serving the army after complet-ing graduate school. His research interest includes the resource allocation in Long-Term Evolution and WiMAX networks.
