# Patent

## Title
Method and apparatus for resource allocation and scheduling

## Abstract

A method and apparatus for resource allocation and scheduling within a wireless communication system is provided herein. During resource allocation, a maximum total system transmit power (P), a maximum number of codes available (N), a maximum number of codes for each user in the system (N=(N1, . . . , Nd)), a maximum SINR value (S=(S1, . . . , Sd)) for each user in the system, and a SINR per watt of transmit power for each user in the system (e=(e1, . . . , ed)) is received by a scheduler. Scheduler then outputs an optimal number of codes per user (n) and power levels per user to (p).

## Background
REFERENCE(S) TO RELATED APPLICATION(S)
The present application claims priority from provisional application, Ser. No. 60/523,971, entitled “METHOD AND APPARATUS FOR RESOURCE ALLOCATION AND SCHEDULING,” filed Nov. 21, 2003, which is commonly owned and incorporated herein by reference in its entirety.


FIELD OF THE INVENTION
The present invention relates generally to resource allocation and scheduling and in particular, to resource allocation and scheduling in an over-the-air communication system.
BACKGROUND OF THE INVENTION
Resource allocation and scheduling within communication systems is generally known in the art. During resource allocation and scheduling, a system controller determines channel parameters for each user, along with a schedule for data transmission. For example, each user within a communication system may be assigned a coding scheme, a power, a number of codes utilized, and a data rate. As known, a communication system generally comprises many users each having their own transmission parameters. A challenge becomes optimizing the communication system by appropriately scheduling each user, and picking appropriate system parameters for each user. Therefore, a need exists for a method and apparatus for scheduling and resource allocation within a communication system that generally optimizes system performance.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 is a block diagram of a transmission circuitry in accordance with an embodiment of the present invention.
FIG. 2 is a flow chart showing operation of the circuitry of FIG. 1 with an embodiment of the present invention.
FIG. 3 is a flow chart showing operation of the circuitry of FIG. 1 with another embodiment of the present invention.



DETAILED DESCRIPTION OF THE INVENTION
To address the need for resource allocation and scheduling, a method and apparatus for resource allocation and scheduling within a wireless communication system is provided herein. During resource allocation, a maximum total system transmit power (P), a maximum number of codes available (N), a maximum number of codes for each user in the system (N=(N1, . . . , Nd)), a maximum SINR value (S=(S1, . . . , Sd)) for each user in the system, and a SINR per watt of transmit power for each user in the system (e=(e1, . . . , ed)) is received by a scheduler. Scheduler then outputs an optimal number of codes per user (n) and power levels per user (p) based on P, N, N, and S.
The present invention encompasses a method for resource allocation. The method comprises the steps of receiving a maximum total system transmit power (P), receiving a maximum number of system codes available (N), receiving a maximum number of codes for each user in the system (N), receiving a maximum SINR value (S) for each user in the system, receiving a SINR per watt of transmit power value for each user in the system (e), determining an optimal number of codes per user (n) and optimal power levels per user (p) based on P, N, N, S, and e, and scheduling users with operating parameters based on n and p.
The present invention additionally encompasses a method for resource allocation. The method comprises the steps of determining a value for an optimal number of codes per user (n) within a communication system, and determining an optimal rate per user (r) and an optimal power per user to) based on n.
The present invention additionally encompasses an apparatus comprising a scheduler receiving a maximum total system transmit power (P), a maximum number of system codes available (N), a maximum number of codes for each user in the system (N), a maximum SINR value (S) for each user in the system, and a SINR per watt of transmit power value for each user in the system (e), the scheduler outputting an optimal number of codes per user (n) and optimal power levels per user to) based on P, N, N, S, and e.
Turning now to the drawings, wherein like numerals designate like components, FIG. 1 is a block diagram of transmission circuitry 100. As shown, transmission circuitry 100 comprises scheduler/optimizer 101, controller 103, and plurality of transmitters 105. During operation, system parameters enter scheduler 101. Scheduler 101 then computes an optimized set of transmission parameters for each transmitter 105 and passes this information to controller 103. During data transmission, controller 103 receives data destined to individual users, and utilizes the set of optimized transmission parameters to appropriately control transmitters 105. When data is passed to transmitters 105, transmitters 105 utilize the transmission parameters to appropriately transmit data to individual users.
As an example, scheduler/optimizer 101 receives a set of users from controller 103 and selects the users for transmission. For each of the users selected, scheduler/optimizer 101 chooses a physical-layer operating point (PLOP) which comprises a particular modulation and coding scheme (MCS), a particular transmit power, a particular number of codes, and a particular information rate. Each PLOP consumes different amounts of overall code and power resources.
Scheduler/optimizer 101 picks the “optimal” PLOP for each user such that the overall system is optimized. In particular, the optimal PLOP for each user is chosen so that a sum of a weighted combination of the rates assigned to users is maximized. The preferred value for the weight vector is the gradient of the utility function at the current throughput estimate
As discussed above, scheduler/optimizer 101 has the task of optimizing overall system performance based on a given set of input parameters. In the preferred embodiment of the present invention this is accomplished by optimizing a scheduling and resource allocation algorithm. The following text describes, 1) the generation of the resource allocation algorithm, and 2) the optimization of the resource allocation algorithm.
1. Generation of the Resource Allocation Algorithm
Simply stated, optimizing a scheduling algorithm involves maximizing the dot product of the “gradient of utility” (as a function of the throughput and the queue length) defined as ∇U(Wt, Qt):=φ∇wU(Wt,Qt)−∇QU(Wt,Qt) and the rate vector rt to be selected at each scheduling time t, where:
U is a utility function,
Wt=(W1,t, . . . , Wd,t) is an estimate of user throughput,
Qt=(Q1,t, . . . , Qd,t) is the user queue length or delay,
∇wU(W1, Q1) is a vector of partial derivatives of U with respect to W,
∇QU(W1, Q1) is a vector of partial derivatives of U with respect to Q,
rt=(r1,t, . . . , rd,t) is a rate vector selected, and
d is the number of users.
That is, we would like to pick the rate vector from the state dependent rate region R(et), which has the highest projection on the gradient of the utility. The rate region depends on the channel state. While the channel state is not perfectly known we assume there is some estimate of it available through a quality (e.g., CQI) feedback, etc. In particular, we assume that we know the predicted SINR per watt of transmitted power ei,t for each user i and that et=(e1,t, . . . , ed,t) captures the channel state




  
    
      max
      
        
          r
          t
        
        ∈
        
          R
          ⁡
          
            (
            
              e
              t
            
            )
          
        
      
    
    ⁢
    
      
        ∇
        
          
            U
            ⁡
            
              (
              
                
                  W
                  t
                
                ,
                
                  Q
                  t
                
              
              )
            
          
          T
        
      
      ·
      
        r
        t
      
    
  
  =
  
    
      max
      
        
          r
          t
        
        ∈
        
          
            R
            ⁡
            
              (
              
                e
                t
              
              )
            
          
          i
        
      
    
    ⁢
    
      
        
          
            U
            .
          
          i
        
        ⁡
        
          (
          
            
              W
              
                i
                ,
                t
              
            
            ,
            
              Q
              
                i
                ,
                t
              
            
          
          )
        
      
      ⁢
      
        r
        
          i
          ,
          t
        
      
    
  




For a certain class of utility functions we have





  
    
      
        
          
            
              U
              .
            
            i
          
          ⁡
          
            (
            
              
                W
                i
              
              ,
              
                Q
                i
              
            
            )
          
        
        :=
        
          
            φ
            ⁢
            
              ∂
              
                ∂
                
                  W
                  i
                
              
            
            ⁢
            
              
                U
                i
              
              ⁡
              
                (
                
                  
                    W
                    i
                  
                  ,
                  
                    Q
                    i
                  
                
                )
              
            
          
          -
          
            
              ∂
              
                ∂
                
                  Q
                  i
                
              
            
            ⁢
            
              
                U
                i
              
              ⁡
              
                (
                
                  
                    W
                    i
                  
                  ,
                  
                    Q
                    i
                  
                
                )
              
            
          
        
      
    
    
      
        (
        1
        )
      
    
  
  
    
      
        
          
        
        ⁢
        
          =
          
            
              φ
              ⁢
              
                
              
              ⁢
              
                c
                i
              
              ⁢
              
                W
                i
                
                  α
                  -
                  1
                
              
            
            +
            
              
                b
                i
              
              ⁢
              
                Q
                i
                
                  p
                  -
                  1
                
              
            
          
        
      
    
    
      
        
      
    
  
  
    
      
        
          
        
        ⁢
        
          
            =
          
          ⁢
          
            :
          
          ⁢
          
            
          
          ⁢
          
            w
            i
          
        
      
    
    
      
        
      
    
  




where

ci is the QoS weight associated with the throughput for useri,
di is the QoS weight associated with the queue length for user i,
φ is filter coefficient associated with the throughput,
α is a fairness parameter associated with the throughput,
p is a fairness parameter associated with the queue length.
Thus the optimization problem results in




  
    max
    
      r
      ∈
      
        R
        ⁡
        
          (
          e
          )
        
      
    
  
  ⁢
  
    
      ∑
      i
    
    ⁢
    
      
        w
        i
      
      ⁢
      
        r
        i
      
    
  




where wi is given by equation (1) above and where we have suppressed the dependence on time t for convenience. Note that selection of the rate ri is coupled with the selection of the physical layer operating point (PLOP) that includes the number of codes ni and the power pi. These PLOP variables need to satisfy system and per user constraints such as




  
    
      n
      i
    
    ≤
    
      N
      i
    
  




  
    
      
        ∑
        i
      
      ⁢
      
        n
        i
      
    
    ≤
    N
  




  
    
      
        ∑
        i
      
      ⁢
      
        p
        i
      
    
    ≤
    P
  



and these are part of the description of the state dependent rate region R(e). As described in U.S. Patent Publication No. US 2002/0147022 “Method for Packet Scheduling and Radio Resource Allocation in a Wireless Communication System,” by Agrawal, et al., the rate per code can be written in terms of the signal to noise ratio (SINR) per code so that





  
    
      r
      i
    
    
      n
      i
    
  
  =
  
    Γ
    ⁡
    
      (
      
        SINR
        i
      
      )
    
  




where the SINR per code is given by





  
    SINR
    i
  
  =
  
    
      
        p
        i
      
      
        n
        i
      
    
    ⁢
    
      e
      i
    
  




and where Γ is some appropriate function. A reasonable choice of the function Γ is the well known information theoretic channel capacity formula Γ(x)=Blog(1+x). Such a functional relation between the rate and the SINR also provides a good curve fit to the High-Speed Downlink Packet Access (HSDPA) MCS table with B equal to the symbol rate (chip rate/spreading factor) which for HSDPA is B=3840000/16=240000 symbols/sec. Note also that for the best curve fit, the SINR is decreased by a factor of A=1.7, i.e., Γ(x)≈Blog(1+x/A) is used. Plugging in this formula results in the following equation for the rate ri in terms of ei, ni, pi:





  
    
      
        
          r
          i
        
        =
        
          
            n
            i
          
          ⁢
          B
          ⁢
          
            
          
          ⁢
          
            log
            ⁡
            
              (
              
                1
                +
                
                  
                    
                      p
                      i
                    
                    ⁢
                    
                      e
                      i
                    
                  
                  
                    An
                    i
                  
                
              
              )
            
          
        
      
    
    
      
        (
        2
        )
      
    
  




Note that the SINR per watt of transmit power on a HS-PDSCH code is given by:





  
    e
    i
  
  =
  
    
      
        (
        
          
            E
            c
          
          
            N
            t
          
        
        )
      
      pilot
    
    ⁢
    
      16
      
        P
        pilot
      
    
  




For notational simplicity ei is redefined to be ei/A the “effective” SINR per watt of transmit power on a HS-PDSCH code, i.e.,





  
    e
    i
  
  =
  
    
      
        (
        
          
            E
            c
          
          
            N
            t
          
        
        )
      
      pilot
    
    ⁢
    
      16
      
        P
        pilot
      
    
    ⁢
    
      1
      A
    
  




The rate region is then given by





  
    
      
        
          R
          ⁡
          
            (
            e
            )
          
        
        =
        
          {
          
            
              
                r
                ≥
                
                  0
                  ⁢
                  
                    :
                  
                  ⁢
                  
                    
                  
                  ⁢
                  
                    r
                    i
                  
                
              
              =
              
                
                  n
                  i
                
                ⁢
                B
                ⁢
                
                  
                
                ⁢
                
                  log
                  ⁡
                  
                    (
                    
                      1
                      +
                      
                        
                          
                            p
                            i
                          
                          ⁢
                          
                            e
                            i
                          
                        
                        
                          n
                          i
                        
                      
                    
                    )
                  
                
              
            
            ,
          
        
      
    
    
      
        
      
    
  
  
    
      
        
          
        
        ⁢
        
          
            
              n
              i
            
            ≤
            
              
                N
                i
              
              ⁢
              
                ∀
                i
              
            
          
          ,
          
            
              
                ∑
                i
              
              ⁢
              
                n
                i
              
            
            ≤
            N
          
          ,
          
            
              
                ∑
                i
              
              ⁢
              
                p
                i
              
            
            ≤
            P
          
        
        }
      
    
    
      
        
      
    
  




By redefining wi to be





  
    w
    i
  
  =
  
    
      B
      ⁡
      
        (
        
          
            φ
            ⁢
            
              
            
            ⁢
            
              c
              i
            
            ⁢
            
              W
              i
              
                α
                -
                1
              
            
          
          +
          
            
              b
              i
            
            ⁢
            
              Q
              i
              
                p
                -
                1
              
            
          
        
        )
      
    
    
      ln
      ⁢
      
        
      
      ⁢
      2
    
  




where

w=(w1, . . . , wd) is the gradient vector,
W=(W1, . . . , Wd) is estimated throughput vector for all the users,
Q=(Q1, . . . , Qd) is estimated throughput vector for all the users,
ci is the QoS weight (possibly 0) associated with the throughput for user i,
di is the QoS weight (possibly 0) associated with the queue length for user i,
φ is filter coefficient associated with the throughput,
α is a fairness parameter associated with the throughput,
p is a fairness parameter associated with the queue length,
B is a scaling constant to match up the formula to bits.
This is a specific instance of the weight vector w=(w1, . . . , wd); however, in general wi cab be any function of the throughput Wi and queue length Qi which is non-increasing in the throughput and non-decreasing in the queue length. The function may also take as parameters various QoS related information such as delay requirement, QoS class, bandwidth requirement, etc.
The optimization problem can be rewritten as

V*:=max(n,p)εχV(n,p)  (3)

subject to





  
    
      
        
          
            ∑
            i
          
          ⁢
          
            n
            i
          
        
        ≤
        N
      
    
    
      
        
      
    
  
  
    
      
        
          
            ∑
            i
          
          ⁢
          
            p
            i
          
        
        ≤
        
          P
          ⁢
          
            
          
          ⁢
          where
        
      
    
    
      
        
      
    
  
  
    
      
        
          
            V
            ⁡
            
              (
              
                n
                ,
                p
              
              )
            
          
          :=
          
            
              ∑
              i
            
            ⁢
            
              
                w
                i
              
              ⁢
              
                n
                i
              
              ⁢
              
                ln
                ⁡
                
                  (
                  
                    1
                    +
                    
                      
                        
                          p
                          i
                        
                        ⁢
                        
                          e
                          i
                        
                      
                      
                        n
                        i
                      
                    
                  
                  )
                
              
            
          
        
        ,
      
    
    
      
        (
        4
        )
      
    
  
  
    
      
        
          X
          :=
          
            {
            
              
                (
                
                  n
                  ,
                  p
                
                )
              
              ≥
              
                0
                ⁢
                
                  :
                
                ⁢
                
                  
                
                ⁢
                
                  n
                  i
                
              
              ≤
              
                
                  N
                  i
                
                ⁢
                
                  
                
                ⁢
                
                  ∀
                  i
                
              
            
            }
          
        
        ,
      
    
    
      
        
      
    
  




n is a vector of code allocations, i.e. a vector comprising codes per user,
p is a vector of power allocations, i.e., a vector comprising power levels per user,
w is the vector of wis, and
e is the vector of eis.
Note that the constraint set χ is convex. It can also be verified that V is concave in (n,p). In case of a retransmission for a user i the “effective” SINR per watt per code ei of that user may be bumped up by a suitable factor.
In addition to the constraints captured above, the following per user power constraints are allowed, any of which may be rendered redundant by a suitable setting of the parameters.

    
    
        peak power constraint:

pi≦Pi, ∀i.

        SINR constraint:
    
    






  
    
      SINR
      i
    
    =
    
      
        
          
            
              p
              i
            
            ⁢
            
              e
              i
            
          
          
            n
            i
          
        
        ≤
        
          S
          i
        
      
      ⇔
      
        
          p
          i
        
        ≤
        
          
            S
            i
          
          ⁢
          
            
              n
              i
            
            
              e
              i
            
          
        
      
    
  
  ,
  
    ∀
    
      i
      .
    
  




    
    
        rate per code (note that the encoder rate assuming a fixed modulation order is a constant times this, viz. the encoder rate is the rate per code divided by the coded output rate which itself is the product of modulation order (2 or 4) times the symbol rate (240000 symbols/sec for HSDPA))
        rate
    
    






  
    
      
        
          
            r
            i
          
          
            n
            i
          
        
        =
        
          
            
              ln
              ⁡
              
                (
                
                  1
                  +
                  
                    
                      
                        p
                        i
                      
                      ⁢
                      
                        e
                        i
                      
                    
                    
                      n
                      i
                    
                  
                
                )
              
            
            ≤
            
              
                (
                
                  R
                  /
                  N
                
                )
              
              i
            
          
          ⇔
          
            
              p
              i
            
            ≤
            
              
                (
                
                  
                    e
                    
                      
                        (
                        
                          R
                          /
                          N
                        
                        )
                      
                      i
                    
                  
                  -
                  1
                
                )
              
              ⁢
              
                
                  n
                  i
                
                
                  e
                  i
                
              
              ⁢
              
                
              
              ⁢
              
                ∀
                
                  i
                  .
                
              
            
          
        
      
    
    
      
        (
        5
        )
      
    
  
  
    
      
        
          r
          i
        
        =
        
          
            
              
                n
                i
              
              ⁢
              
                ln
                ⁡
                
                  (
                  
                    1
                    +
                    
                      
                        
                          p
                          i
                        
                        ⁢
                        
                          e
                          i
                        
                      
                      
                        n
                        i
                      
                    
                  
                  )
                
              
            
            ≤
            
              R
              i
            
          
          ⇔
          
            
              p
              i
            
            ≤
            
              
                (
                
                  
                    e
                    
                      
                        R
                        i
                      
                      /
                      
                        n
                        i
                      
                    
                  
                  -
                  1
                
                )
              
              ⁢
              
                
                  n
                  i
                
                
                  e
                  i
                
              
              ⁢
              
                
              
              ⁢
              
                ∀
                
                  i
                  .
                
              
            
          
        
      
    
    
      
        
      
    
  




All of the above per user power constraints are special cases of




  
    
      
        
          
            SINR
            i
          
          =
          
            
              
                
                  p
                  i
                
                ⁢
                
                  e
                  i
                
              
              
                n
                i
              
            
            ≤
            
              
                s
                i
              
              ⁡
              
                (
                
                  n
                  i
                
                )
              
            
          
        
        ,
        
          ∀
          i
        
        ,
      
    
    
      
        (
        6
        )
      
    
  




where the function si is also dependent on the fixed (for the optimization problem) parameters Pi,ei,Si,Ri,(R/N)i. In fact all of the above constraints can be combined into the single constraint (6) above with





  
    
      s
      i
    
    ⁡
    
      (
      
        n
        i
      
      )
    
  
  =
  
    min
    ⁢
    
      {
      
        
          
            
              P
              i
            
            ⁢
            
              e
              i
            
          
          
            n
            i
          
        
        ,
        
          S
          i
        
        ,
        
          (
          
            
              e
              
                
                  (
                  
                    R
                    /
                    N
                  
                  )
                
                i
              
            
            -
            1
          
          )
        
        ,
        
          (
          
            
              e
              
                
                  R
                  i
                
                /
                
                  n
                  i
                
              
            
            -
            1
          
          )
        
      
      }
    
  




Two special cases of this of interest are:

    
    
        1. si(ni)≡si does not depend on ni.
        2. si(ni)≡si=∞.
    
    


With the per user power constraints, the constraint set χ is further restricted to

χ:={(n,p)≧0: ni≦Ni, pi≦si(ni)ni/ei ∀i}  (7)

The constraint set continues to be convex if si(ni)ni is a concave function of ni. Note that si(ni)ni is indeed a concave function of ni for the two special case (1-2) mentioned above. However, for the rate constraint case (equation 18), si(ni)ni is convex in ni.
1.1 Handling Retransmissions
As mentioned earlier, users with retransmissions need to be treated differently in two respects:

    
    
        1. Their effective SINR per watt per code needs to be increased.
        2. They have an equality constraint on their rate ri=Ri 
    
    


The first can be handled easily by adjusting their ei appropriately. To handle the latter constraint, we observe that the rate constraint is equivalent to




  
    
      
        
          r
          i
        
        =
        
          
            
              B
              
                ln
                ⁢
                
                  
                
                ⁢
                2
              
            
            ⁢
            
              n
              i
            
            ⁢
            
              ln
              ⁡
              
                (
                
                  1
                  +
                  
                    
                      
                        p
                        i
                      
                      ⁢
                      
                        e
                        i
                      
                    
                    
                      n
                      i
                    
                  
                
                )
              
            
          
          =
          
            
              
                R
                i
              
              ⇔
              
                p
                i
              
            
            =
            
              
                
                  n
                  i
                
                
                  e
                  i
                
              
              ⁢
              
                (
                
                  
                    e
                    
                      
                        
                          R
                          i
                        
                        ⁢
                        ln
                        ⁢
                        
                          
                        
                        ⁢
                        2
                      
                      
                        Bn
                        i
                      
                    
                  
                  -
                  1
                
                )
              
            
          
        
      
    
    
      
        (
        8
        )
      
    
  




2. Operation of Scheduler/Optimizer

Scheduler/optimizer 101 receives a set of parameters and solves for V* by optimizing the resource allocation algorithm of equation (3). More particularly, scheduler/optimizer 101 receives
P=Maximum total system transmit power,
N=Maximum total codes available to the system,
N=Vector comprising the maximum number of codes (e.g., spreading codes) for each user in the system,
R=Vector comprising the maximum data rate for each user in the system,
R/N=Vector comprising the maximum data rate per code for each user in the system,
P=Vector comprising the maximum transmit power for each user in the system,
S=Vector comprising the maximum noise (e.g., SINR) for each user in the system,
e=Vector comprising the noise (e.g., SINR) per power (e.g., SINR per watt) for each user in the system,
W=Vector comprising the estimated throughput vector for each user in the system,
Q=Vector comprising the queue length vector for each user in the system,
c=Vector comprising the QoS weight associated with the throughput for each user in the system, and
b=Vector comprising the QoS weight associated with the queue length for each user in the system.
In the preferred embodiment of the present invention scheduler/optimizer 101 determines optimal values of ri, ni, and pi for each user i, outputting vectors r, n, and p for communication system 100. As discussed above, vectors r, n, and p for communication system 100 are determined by solving for V* in equation (3) given the set of input parameters described above. Scheduler/optimizer 101 solves for V* subject to the additional constraints described above in (7).
2.1 First Embodiment
In case




  
    
      
        ∑
        i
      
      ⁢
      
        N
        i
      
    
    ≤
    N
  
  ,
  
    
      n
      i
    
    =
    
      N
      i
    
  




is the optimal code allocation, we are left with just a power optimization problem which can be solved very easily as shown later. Henceforth, we will tackle the case when this is not the case, i.e.,





  
    
      ∑
      i
    
    ⁢
    
      N
      i
    
  
  >
  
    N
    .
  




Also, we allow ni to take on non-integer values as a relaxation to the integer optimization problem. We find that in most cases, the optimal solution turns out to assign integer values to ni. We solve the optimization problem by looking at the dual formulation. Define the Lagrangian





  
    L
    ⁡
    
      (
      
        p
        ,
        n
        ,
        λ
        ,
        μ
      
      )
    
  
  =
  
    
      
        ∑
        i
      
      ⁢
      
        
          w
          i
        
        ⁢
        
          n
          i
        
        ⁢
        
          ln
          ⁡
          
            (
            
              1
              +
              
                
                  
                    p
                    i
                  
                  ⁢
                  
                    e
                    i
                  
                
                
                  n
                  i
                
              
            
            )
          
        
      
    
    +
    
      λ
      (
      
        P
        -
        
          
            ∑
            i
          
          ⁢
          
            p
            i
          
        
      
      )
    
    +
    
      μ
      (
      
        N
        -
        
          
            ∑
            i
          
          ⁢
          
            n
            i
          
        
      
      )
    
  




Based on this we can define the dual function

L(λ,μ):=max(n,p)εχL(p,n,λ,μ)  (9)

where

χ is set of valid choices for (n,p) given by the constraint set (7),
λ is Lagrange multiplier for the power constraint, and
μ is Lagrange multiplier for the code constraint.
The dual problem is to find

L*:=min(λ,μ)≧0L(λ,μ)  (10)

Also, define

L(λ):=minμ≧0L(λ,μ)=max(n,p)εχL(p,n,λ,μ)  (11)

For this part of the solution we will ignore the rate constraint (5) ((8) for retransmissions) or replace it with a linear constraint as described below in “Handling rate restrictions.”
Note: Handling Rate Restrictions
The constraint set with the rate restriction (5) or (8) is non-convex, which would not allow us to optimize over ni very easily. To simply matters, we may assume that ni=Ni in the second term on the right. Thus we assume that (5) is replaced by




  
    p
    i
  
  ≤
  
    
      
        n
        i
      
      
        e
        i
      
    
    ⁢
    
      (
      
        
          e
          
            
              
                R
                i
              
              ⁢
              ln
              ⁢
              
                
              
              ⁢
              2
            
            
              BN
              i
            
          
        
        -
        1
      
      )
    
  




In case of constraint (8), we can replace it by





  
    p
    i
  
  =
  
    
      
        n
        i
      
      
        e
        i
      
    
    ⁢
    
      
        (
        
          
            e
            
              
                
                  R
                  i
                
                ⁢
                ln
                ⁢
                
                  
                
                ⁢
                2
              
              
                BN
                i
              
            
          
          -
          1
        
        )
      
      .
    
  




This may be justified on a few different grounds. First, we have observed that in many cases the optimal ni=Ni. Secondly substituting ni=Ni makes things a bit worse for this user, but the bump up in ei (for the case of retransmissions) will increase the wiei of this user which should probably still help select this user. We could also try putting a different linear approximation to the above constraint. Note that this constraint is only needed for the code allocation part. Some other heuristics are also possible. For instance we may replace the rate constraint as above and if we still pick this user and it gets ni=Ni, then we have most likely not sacrificed anything. Similarly we could try ni=1 in the second term which should make the user more likely to be selected. If it is still not selected, once again we have probably not sacrificed anything by this approximation. However for the cases in between (which would probably be rare), we may want to explicitly vary the ni for this user explicitly and optimize. Note that once the code allocation is made, we can work with the original rate constraint for the optimizations over powers.
Since the objective function is concave and the constraint set is convex, there is no duality gap allowing us to use the solution of the dual to compute the solution of the primal.
Based on this the scheduler/optimizer 101 determines appropriate values for r, n, and p via the following steps (also illustrated in FIG. 2):

    
    
        1. Collect all the input parameters P, N, N, R, R/N, P, S, e, W, Q, c, b. (Step 201)
        2. For a fixed λ and μ find the optimal (n,p) analytically. (Step 203)
        3. Then keeping λ fixed, find the optimal μ*(λ). (Step 205)
        4. Also, keeping λ fixed, calculate L(λ) as defined in equation (11). (Step 207).
        5. Numerically search for the optimal λ=λ*, in other words, search for the value of λ that minimizes L(λ) to obtain L*. (Step 209)
        6. Calculate n=n*(λ*,μ*(λ*)) (Step 211)
        7. Calculate optimal p and r keeping n fixed. (Step 213)
    
    


FIG. 2 is a flow chart showing operation of scheduler/optimizer 101. The logic flow begins at step 201 where e, P, N, N, and S are collected by the optimizer 101. At step 203 n and p are calculated analytically by keeping λ and μ fixed. In particular λ and μ are fixed but arbitrary and n and p are calculated as a function of λ and μ to optimize the Lagrangian in order to obtain the dual function as shown in equation (9).
At step 205 λ is fixed but arbitrary and an optimal μ*(λ) is determined so that we minimize the dual function L(λ,μ) to obtain L(λ). L(λ) is calculated per equation 23 at step 207 and a numerical search for an optimal λ=λ* occurs at step 209. In other words, at step 209 λ=λ* is determined so that L*=L(λ*)=minλ≧0L(λ). At step 211 n=n*(λ*,μ*(λ*)) is calculated per equation (14). The vector R is collected and r and p are calculated keeping n fixed (step 213). In particular n is fixed to the value obtained in step 5, and p and r are calculated as per equations (21) and (2) taking the actual rate constraint R into account. Finally, at step 215 values for n, p and r are output to controller 103 and utilized to schedule and transmit data via transmitters 105.
The following discussion further details the steps taken above in FIG. 2.
2.1.1 Step 203, for Fixed λ and μ Find the Optimal (n,p) Analytically
Optimizing the Lagrangian (in the dual) for a fixed λ, μ, and n (this includes the optimization over powers assuming a fixed feasible n) we get




  
    p
    i
    *
  
  =
  
    
      
        n
        i
      
      
        e
        i
      
    
    ⁢
    
      {
      
        
          
            
              0
              ,
            
          
          
            
              
                
                  w
                  i
                
                ⁢
                
                  e
                  i
                
              
              ≤
              λ
            
          
        
        
          
            
              
                
                  
                    
                      w
                      i
                    
                    ⁢
                    
                      e
                      i
                    
                  
                  λ
                
                -
                1
              
              ,
            
          
          
            
              
                
                  
                    w
                    i
                  
                  ⁢
                  
                    e
                    i
                  
                
                
                  1
                  +
                  
                    
                      s
                      i
                    
                    ⁡
                    
                      (
                      
                        n
                        i
                      
                      )
                    
                  
                
              
              ≤
              λ
              <
              
                
                  w
                  i
                
                ⁢
                
                  e
                  i
                
              
            
          
        
        
          
            
              
                
                  s
                  i
                
                ⁡
                
                  (
                  
                    n
                    i
                  
                  )
                
              
              ,
            
          
          
            
              λ
              <
              
                
                  
                    w
                    i
                  
                  ⁢
                  
                    e
                    i
                  
                
                
                  1
                  +
                  
                    
                      s
                      i
                    
                    ⁡
                    
                      (
                      
                        n
                        i
                      
                      )
                    
                  
                
              
            
          
        
      
    
  




or equivalently,





  
    
      
        
          p
          i
          *
        
        =
        
          
            
              
                
                  n
                  i
                
                
                  e
                  i
                
              
              ⁡
              
                [
                
                  min
                  ⁢
                  
                    {
                    
                      
                        
                          
                            
                              w
                              i
                            
                            ⁢
                            
                              e
                              i
                            
                          
                          λ
                        
                        -
                        1
                      
                      ,
                      
                        
                          s
                          i
                        
                        ⁡
                        
                          (
                          
                            n
                            i
                          
                          )
                        
                      
                    
                    }
                  
                
                ]
              
            
            +
          
          .
        
      
    
    
      
        (
        12
        )
      
    
  




The resulting SINR per code is given by





  
    
      
        
          
            
              p
              i
              *
            
            ⁢
            
              e
              i
            
          
          
            n
            i
          
        
        =
        
          
            
              s
              *
            
            ⁡
            
              (
              
                
                  
                    
                      w
                      i
                    
                    ⁢
                    
                      e
                      i
                    
                  
                  λ
                
                ,
                
                  
                    s
                    i
                  
                  ⁡
                  
                    (
                    
                      n
                      i
                    
                    )
                  
                
              
              )
            
          
          :=
          
            
              [
              
                min
                ⁢
                
                  {
                  
                    
                      
                        
                          
                            w
                            i
                          
                          ⁢
                          
                            e
                            i
                          
                        
                        λ
                      
                      -
                      1
                    
                    ,
                    
                      
                        s
                        i
                      
                      ⁡
                      
                        (
                        
                          n
                          i
                        
                        )
                      
                    
                  
                  }
                
              
              ]
            
            +
          
        
      
    
    
      
        (
        13
        )
      
    
  




The last case is vacuous when we have no per user constraints on the powers, i.e., si(ni)=∞. Note that in case si(ni)≡si does not depend on ni, the resulting SINR per code also does not depend on the number of codes ni and the power requirement scales linearly in the number of codes.
Define




  
    h
    ⁡
    
      (
      
        
          
            w
            i
          
          ⁢
          
            e
            i
          
        
        ,
        
          
            s
            i
          
          ⁡
          
            (
            
              n
              i
            
            )
          
        
        ,
        λ
      
      )
    
  
  :=
  
    {
    
      
        
          
            0
            ,
          
        
        
          
            
              
                w
                i
              
              ⁢
              
                e
                i
              
            
            ≤
            λ
          
        
      
      
        
          
            
              [
              
                
                  λ
                  
                    
                      w
                      i
                    
                    ⁢
                    
                      e
                      i
                    
                  
                
                -
                1
                -
                
                  ln
                  ⁢
                  
                    
                  
                  ⁢
                  
                    λ
                    
                      
                        w
                        i
                      
                      ⁢
                      
                        e
                        i
                      
                    
                  
                
              
              ]
            
            ,
          
        
        
          
            
              
                
                  w
                  i
                
                ⁢
                
                  e
                  i
                
              
              
                1
                +
                
                  
                    s
                    i
                  
                  ⁡
                  
                    (
                    
                      n
                      i
                    
                    )
                  
                
              
            
            ≤
            λ
            <
            
              
                w
                i
              
              ⁢
              
                e
                i
              
            
          
        
      
      
        
          
            
              [
              
                
                  ln
                  ⁡
                  
                    (
                    
                      1
                      +
                      
                        
                          s
                          i
                        
                        ⁡
                        
                          (
                          
                            n
                            i
                          
                          )
                        
                      
                    
                    )
                  
                
                -
                
                  
                    λ
                    
                      
                        w
                        i
                      
                      ⁢
                      
                        e
                        i
                      
                    
                  
                  ⁢
                  
                    
                      s
                      i
                    
                    ⁡
                    
                      (
                      
                        n
                        i
                      
                      )
                    
                  
                
              
              ]
            
            ,
          
        
        
          
            λ
            <
            
              
                
                  w
                  i
                
                ⁢
                
                  e
                  i
                
              
              
                1
                +
                
                  
                    s
                    i
                  
                  ⁡
                  
                    (
                    
                      n
                      i
                    
                    )
                  
                
              
            
          
        
      
    
  




Then for case (1) si(ni)≡si does not depend on ni. Additionally,

h(wiei, si (ni),λ)=h(wiei, si, λ)

also does not depend on ni. For this case it is easy to further optimize the Lagrangian over ni to calculate the dual function. In particular, we find that





  
    
      
        
          n
          i
          *
        
        =
        
          
            
              n
              i
              *
            
            ⁡
            
              (
              
                λ
                ,
                μ
              
              )
            
          
          =
          
            {
            
              
                
                  
                    0
                    ,
                  
                
                
                  
                    
                      
                        w
                        i
                      
                      ⁢
                      
                        h
                        ⁡
                        
                          (
                          
                            
                              
                                w
                                i
                              
                              ⁢
                              
                                e
                                i
                              
                            
                            ,
                            
                              s
                              i
                            
                            ,
                            λ
                          
                          )
                        
                      
                    
                    <
                    μ
                  
                
              
              
                
                  
                    
                      0
                      ≤
                      
                        n
                        i
                      
                      ≤
                      
                        N
                        i
                      
                    
                    ,
                  
                
                
                  
                    
                      
                        w
                        i
                      
                      ⁢
                      
                        h
                        ⁡
                        
                          (
                          
                            
                              
                                w
                                i
                              
                              ⁢
                              
                                e
                                i
                              
                            
                            ,
                            
                              s
                              i
                            
                            ,
                            λ
                          
                          )
                        
                      
                    
                    =
                    μ
                  
                
              
              
                
                  
                    
                      N
                      i
                    
                    ,
                  
                
                
                  
                    
                      
                        w
                        i
                      
                      ⁢
                      
                        h
                        ⁡
                        
                          (
                          
                            
                              
                                w
                                i
                              
                              ⁢
                              
                                e
                                i
                              
                            
                            ,
                            
                              s
                              i
                            
                            ,
                            λ
                          
                          )
                        
                      
                    
                    >
                    μ
                  
                
              
            
          
        
      
    
    
      
        (
        14
        )
      
    
  




Note that for the case μ=wih(wiei, si, λ) any 0≦niNi is optimal. Then the dual function is given by





  
    
      
        
          L
          ⁡
          
            (
            
              λ
              ,
              μ
            
            )
          
        
        =
        
          
            
              ∑
              i
            
            ⁢
            
              
                
                  [
                  
                    
                      
                        μ
                        i
                      
                      ⁡
                      
                        (
                        λ
                        )
                      
                    
                    -
                    μ
                  
                  ]
                
                +
              
              ⁢
              
                N
                i
              
            
          
          +
          
            μ
            ⁢
            
              
            
            ⁢
            N
          
          +
          
            λ
            ⁢
            
              
            
            ⁢
            P
          
        
      
    
    
      
        (
        15
        )
      
    
  




where

μi(λ):=wih(wiei,si,λ)

2.1.2 Step 205, Fixing λ and Optimizing μ.

In order to optimize the dual function (15) over μ, we sort the users in decreasing order of μi(λ). Let j* be the smallest integer such that




  
    
      
        
          
            
              
                
                  ∑
                  
                    i
                    =
                    1
                  
                  
                    j
                    *
                  
                
                ⁢
                
                  N
                  i
                
              
              ≥
              N
            
          
        
        
          
            
              
                L
                ⁡
                
                  (
                  λ
                  )
                
              
              :=
              
                
                  min
                  
                    μ
                    ≥
                    0
                  
                
                ⁢
                
                  L
                  ⁡
                  
                    (
                    
                      λ
                      ,
                      μ
                    
                    )
                  
                
              
            
          
        
        
          
            
              
                
              
              ⁢
              
                =
                
                  
                    
                      ∑
                      
                        i
                        =
                        1
                      
                      
                        
                          j
                          *
                        
                        -
                        1
                      
                    
                    ⁢
                    
                      
                        
                          μ
                          i
                        
                        ⁡
                        
                          (
                          λ
                          )
                        
                      
                      ⁢
                      
                        N
                        i
                      
                    
                  
                  +
                  
                    
                      
                        μ
                        
                          j
                          *
                        
                      
                      ⁡
                      
                        (
                        λ
                        )
                      
                    
                    ⁢
                    
                      (
                      
                        N
                        -
                        
                          
                            ∑
                            
                              i
                              =
                              1
                            
                            
                              
                                j
                                *
                              
                              -
                              1
                            
                          
                          ⁢
                          
                            N
                            i
                          
                        
                      
                      )
                    
                  
                  +
                  
                    λ
                    ⁢
                    
                      
                    
                    ⁢
                    P
                  
                
              
            
          
        
      
    
    
      
        (
        16
        )
      
    
  




and the minimizing μ is given by





  
    
      
        
          
            μ
            *
          
          ⁡
          
            (
            λ
            )
          
        
        :=
        
          
            μ
            
              j
              *
            
          
          ⁡
          
            (
            λ
            )
          
        
      
    
    
      
        (
        17
        )
      
    
  




Note that μj(λ)≧μj+1(λ) by the above ordering. Thus μ*(λ) is a threshold; users with their μi(λ)>μ*(λ), get their full code capability and those with μi(λ)<μ*(λ) get none. Also note that when wi≧wj and ei>ej, μi(λ)≧μj(λ), and user i will be given a full code allocation before allocating any codes to user j. This implies that when the fairness parameter α=1 (the “max C/I scheduler”) and all users have the same QoS weight, wi's are constant and identical across users and thus packing users into the code budget in order of their ei's is optimal. This is illustrated below with respect to description of the alternate embodiment of the present invention.
In case μj−1*(λ)>μj*(λ)>μj+1*(λ), there is a unique feasible n* that satisfies the sum code constraint with equality and that optimizes the Lagrangian for μ=μ*(λ). It is given by




  
    
      
        
          n
          i
          *
        
        =
        
          {
          
            
              
                
                  
                    
                      N
                      i
                    
                    ,
                  
                
                
                  
                    i
                    <
                    
                      j
                      *
                    
                  
                
              
              
                
                  
                    
                      N
                      -
                      
                        
                          ∑
                          
                            i
                            =
                            1
                          
                          
                            
                              j
                              *
                            
                            -
                            1
                          
                        
                        ⁢
                        
                          N
                          i
                        
                      
                    
                    ,
                  
                
                
                  
                    i
                    =
                    
                      j
                      *
                    
                  
                
              
              
                
                  
                    0
                    ,
                  
                
                
                  
                    i
                    >
                    
                      j
                      *
                    
                  
                
              
            
            .
          
        
      
    
    
      
        (
        18
        )
      
    
  




However, if this is not the case, there is a tie and there are multiple n* that optimize the Lagrangian. However, not all of these choices of n* and the resulting p* given by (18) and (12) will be feasible. In order to achieve feasibility we must also satisfy the additional code and power constraints. Let n*(λ) denote any of the maximizing n constructed above.

We have just shown that the optimal code allocation has the following properties:
1. For the case of Ni=N at most two users will be scheduled.
2. If all Ni are equal, then at most ┌N/Ni┐+1 users will be scheduled. All but two users will have their full code allocation.
3. In general all but two users will have their full code allocation.
2.1.3 Step 213 Calculating r and p While Keeping n Fixed.
In step 213 we solve for the optimal powers given a code allocation n. It should be noted that n may be derived as discussed above with reference to steps 203 and 205, or alternatively, n may be pre-determined and provided as an input into the power-optimization algorithm. Denote by

V*(n):=max{p≧0: pi≦si(ni)ni/ei ∀i}V(n,p)

subject to





  
    
      ∑
      i
    
    ⁢
    
      p
      i
    
  
  ≤
  
    P
    .
  




This is solved by finding λ*(n) using the dual formulation and then computing the optimal p*(n) as described before. Since n is fixed there are no restrictions on the function nisi(ni) except that it has to be non-negative. Thus, we can incorporate the rate constraints in the calculations performed in this step.
Without loss of generality we remove any users with zero code allocations. Let M be the number of users with positive code allocation. We first need to check if the sum power constraint is inactive, i.e.,




  
    
      ∑
      i
    
    ⁢
    
      p
      i
    
  
  =
  
    
      
        ∑
        i
      
      ⁢
      
        
          
            n
            i
          
          
            e
            i
          
        
        ⁢
        
          
            s
            i
          
          ⁡
          
            (
            
              n
              i
            
            )
          
        
      
    
    ≤
    
      P
      .
    
  




If this is the case the optimal power allocations are just the individual power constraints





  
    p
    i
    *
  
  =
  
    
      
        n
        i
      
      
        e
        i
      
    
    ⁢
    
      
        s
        i
      
      ⁡
      
        (
        
          n
          i
        
        )
      
    
  




and we are done.

Henceforth, we proceed when this constraint is active. In this case we can show that the sum power constraint must be satisfied with equality for the optimal powers (otherwise at least one of the users' powers can be increased resulting in a higher primal value function). We can now construct the Lagrangian in the sum power constraint alone.




  
    
      L
      p
    
    ⁡
    
      (
      
        p
        ,
        λ
      
      )
    
  
  :=
  
    
      
        ∑
        i
      
      ⁢
      
        
          w
          i
        
        ⁢
        
          n
          i
        
        ⁢
        
          
        
        ⁢
        
          ln
          ⁡
          
            (
            
              1
              +
              
                
                  
                    p
                    i
                  
                  ⁢
                  
                    e
                    i
                  
                
                
                  n
                  i
                
              
            
            )
          
        
      
    
    +
    
      λ
      ⁡
      
        (
        
          P
          -
          
            ∑
            
              p
              i
            
          
        
        )
      
    
  




In case





  
    
      
        ∑
        i
      
      ⁢
      
        n
        i
      
    
    =
    N
  
  ,




the two Lagrangians are equal. The dual function is given by

Lp(λ):=max{p≧0: pi≦si(ni)ni/ei ∀i}Lp(p,λ).

Note that for optimizing over powers, the constraint set is always convex regardless of the function si(ni)ni. Maximizing Lp(p,λ) over p is essentially the same as the problem for L(p,n,λ,μ) as covered in the previous section. The optimal p is given by (12) as before, i.e.,




  
    
      
        
          
            p
            i
            *
          
          ⁡
          
            (
            
              n
              ,
              λ
            
            )
          
        
        =
        
          
            
              
                
                  n
                  i
                
                
                  e
                  i
                
              
              ⁡
              
                [
                
                  min
                  ⁢
                  
                    {
                    
                      
                        
                          
                            
                              w
                              i
                            
                            ⁢
                            
                              e
                              i
                            
                          
                          λ
                        
                        -
                        1
                      
                      ,
                      
                        
                          s
                          i
                        
                        ⁡
                        
                          (
                          
                            n
                            i
                          
                          )
                        
                      
                    
                    }
                  
                
                ]
              
            
            +
          
          .
        
      
    
    
      
        (
        19
        )
      
    
  




In Agrawal et al. it was shown that λ*(n) optimizes Lp(λ) if and only if the corresponding p*(n,λ) satisfies




  
    
      ∑
      i
    
    ⁢
    
      p
      i
      *
    
  
  =
  
    P
    .
  




Substituting from (19) we get that λ*(n) is given by any solution of the equation:





  
    
      
        λ
        =
        
          
            
              
                ∑
                i
              
              ⁢
              
                
                  n
                  i
                
                ⁢
                
                  w
                  i
                
                ⁢
                
                  1
                  
                    {
                    
                      
                        
                          
                            w
                            i
                          
                          ⁢
                          
                            e
                            i
                          
                        
                        
                          1
                          +
                          
                            
                              s
                              i
                            
                            ⁡
                            
                              (
                              
                                n
                                i
                              
                              )
                            
                          
                        
                      
                      ≤
                      λ
                      <
                      
                        
                          w
                          i
                        
                        ⁢
                        
                          e
                          i
                        
                      
                    
                    }
                  
                
              
            
            
              P
              -
              
                
                  ∑
                  i
                
                ⁢
                
                  
                    
                      
                        n
                        i
                      
                      ⁢
                      
                        
                          s
                          i
                        
                        ⁡
                        
                          (
                          
                            n
                            i
                          
                          )
                        
                      
                    
                    
                      e
                      i
                    
                  
                  ⁢
                  
                    1
                    
                      {
                      
                        λ
                        <
                        
                          
                            
                              w
                              i
                            
                            ⁢
                            
                              e
                              i
                            
                          
                          
                            1
                            +
                            
                              
                                s
                                i
                              
                              ⁡
                              
                                (
                                
                                  n
                                  i
                                
                                )
                              
                            
                          
                        
                      
                      }
                    
                  
                
              
              +
              
                
                  ∑
                  i
                
                ⁢
                
                  
                    
                      n
                      i
                    
                    
                      e
                      i
                    
                  
                  ⁢
                  
                    1
                    
                      {
                      
                        
                          
                            
                              w
                              i
                            
                            ⁢
                            
                              e
                              i
                            
                          
                          
                            1
                            +
                            
                              
                                s
                                i
                              
                              ⁡
                              
                                (
                                
                                  n
                                  i
                                
                                )
                              
                            
                          
                        
                        ≤
                        λ
                        <
                        
                          
                            w
                            i
                          
                          ⁢
                          
                            e
                            i
                          
                        
                      
                      }
                    
                  
                
              
            
          
          .
        
      
    
    
      
        (
        20
        )
      
    
  




Then the optimal power allocation vector p*(n) is given by




  
    
      
        
          
            p
            i
            *
          
          ⁡
          
            (
            n
            )
          
        
        =
        
          
            
              p
              i
              *
            
            ⁡
            
              (
              
                n
                ,
                
                  
                    λ
                    *
                  
                  ⁡
                  
                    (
                    n
                    )
                  
                
              
              )
            
          
          =
          
            
              
                
                  
                    n
                    i
                  
                  
                    e
                    i
                  
                
                ⁡
                
                  [
                  
                    min
                    ⁢
                    
                      {
                      
                        
                          
                            
                              
                                w
                                i
                              
                              ⁢
                              
                                e
                                i
                              
                            
                            
                              
                                λ
                                *
                              
                              ⁡
                              
                                (
                                n
                                )
                              
                            
                          
                          -
                          1
                        
                        ,
                        
                          
                            s
                            i
                          
                          ⁡
                          
                            (
                            
                              n
                              i
                            
                            )
                          
                        
                      
                      }
                    
                  
                  ]
                
              
              +
            
            .
          
        
      
    
    
      
        (
        21
        )
      
    
  




Since λ occurs on both sides of equation (20) solving for λ*(n) may seem hard. We provide an algorithm solution to this as follows:

For users i=1, . . . ,M, define




  
    
      
        
          b
          i
        
        =
        
          
            w
            i
          
          ⁢
          
            e
            i
          
        
      
    
  
  
    
      
        
          a
          i
        
        =
        
          
            
              
                w
                i
              
              ⁢
              
                e
                i
              
            
            
              1
              +
              
                
                  s
                  i
                
                ⁡
                
                  (
                  
                    n
                    i
                  
                  )
                
              
            
          
          .
        
      
    
  




Note that ai<bi. Sort the set {ai,bi; i=1, . . . ,2M} into a decreasing set of numbers {x[l];l=1, . . . ,2M}. For, each l=1, . . . ,2M also let y[l]:=i if x[l]=bi or x[l]=ai, and let





  
    z
    ⁡
    
      [
      l
      ]
    
  
  :=
  
    {
    
      
        
          
            
              1
              ,
            
          
          
            
              
                if
                ⁢
                
                  
                
                ⁢
                
                  x
                  ⁡
                  
                    [
                    l
                    ]
                  
                
              
              =
              
                a
                
                  y
                  ⁡
                  
                    [
                    l
                    ]
                  
                
              
            
          
        
        
          
            
              0
              ,
            
          
          
            otherwise
          
        
      
      .
    
  




Ties are resolved arbitrarily. Next find the largest λ ε {x[l]; l=1, . . . ,2M} such that





  
    
      
        ∑
        i
      
      ⁢
      
        
          p
          i
          *
        
        ⁡
        
          (
          
            n
            ,
            λ
          
          )
        
      
    
    ≥
    P
  
  ,




i.e., find the smallest l such that





  
    
      ∑
      i
    
    ⁢
    
      
        p
        i
        *
      
      ⁡
      
        (
        
          n
          ,
          
            x
            ⁡
            
              [
              l
              ]
            
          
        
        )
      
    
  
  ≥
  
    P
    .
  




In the paper “Joint Scheduling and Resource Allocation in CDMA Systems,” by Agrawal et al., we have shown that λ*(n) ε [x[l],x[l−1]) and is given by the solution of equation (20). Moreover for λ in the above range, the indicators in equation (20) are not dependent on the particular value of λ and hence we have an easily computable expression for λ.

Below we provide pseudo-code for an algorithm that finds the solution to the above equation (20). The algorithm complexity is O(MlogM) due to a sort.
Pseudo-code for Preferred Embodiment of Solution λ*(n)












lambda ()


{









Psum = 0;



Ppossum = 0;



Pmaxsum = 0;



nwpossum = 0;



for (i=1, i <= M, i++) {









pos[i] = 0;



max[i] = 0;



}









l = 1;



while (Psum < P && l < 2M) {









i = y[l]



if (z[l] = 1) {



 













  
    
      
        
          
            
              max
              ⁡
              
                [
                i
                ]
              
            
            =
            1
          
          ;
        
      
    
    
      
        
          
            Pmaxsum
            +=
            
              
                
                  n
                  i
                
                
                  e
                  i
                
              
              ⁢
              
                
                  s
                  i
                
                ⁡
                
                  (
                  
                    n
                    i
                  
                  )
                
              
            
          
          ;
        
      
    
    
      
        
          
            //
            Pmaxsum
          
          =
          
            
              ∑
              i
            
            ⁢
            
              (
              
                
                  
                    n
                    i
                  
                  
                    e
                    i
                  
                
                *
                
                  
                    s
                    i
                  
                  ⁡
                  
                    (
                    
                      n
                      i
                    
                    )
                  
                
                *
                
                  max
                  ⁡
                  
                    [
                    i
                    ]
                  
                
              
              )
            
          
        
      
    
    
      
        
          
            Ppossum
            -=
            
              
                n
                i
              
              
                e
                i
              
            
          
          ;
        
      
    
    
      
        
          
            //
            Ppossum
          
          =
          
            
              ∑
              i
            
            ⁢
            
              (
              
                
                  
                    n
                    i
                  
                  
                    e
                    i
                  
                
                *
                
                  (
                  
                    
                      pos
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    -
                    
                      max
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                  )
                
              
              )
            
          
        
      
    
    
      
        
          
            nwpossum
            -=
            
              
                n
                i
              
              *
              
                w
                i
              
            
          
          ;
        
      
    
    
      
        
          
            //
            nwpossum
          
          =
          
            
              ∑
              i
            
            ⁢
            
              (
              
                
                  n
                  i
                
                *
                
                  w
                  i
                
                *
                
                  (
                  
                    
                      pos
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    -
                    
                      max
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                  )
                
              
              )
            
          
        
      
    
  
   












}


else{


 













  
    
      
        
          
            
              pos
              ⁡
              
                [
                i
                ]
              
            
            =
            1
          
          ;
        
      
    
    
      
        
          
            Ppossum
            +=
            
              
                n
                i
              
              
                e
                i
              
            
          
          ;
        
      
    
    
      
        
          
            //
            Ppossum
          
          =
          
            
              ∑
              i
            
            ⁢
            
              (
              
                
                  
                    n
                    i
                  
                  
                    e
                    i
                  
                
                *
                
                  (
                  
                    
                      pos
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    -
                    
                      max
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                  )
                
              
              )
            
          
        
      
    
    
      
        
          
            nwpossum
            +=
            
              
                n
                i
              
              *
              
                w
                i
              
            
          
          ;
        
      
    
    
      
        
          
            //
            nwpossum
          
          =
          
            
              ∑
              i
            
            ⁢
            
              (
              
                
                  n
                  i
                
                *
                
                  w
                  i
                
                *
                
                  (
                  
                    
                      pos
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    -
                    
                      max
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                  )
                
              
              )
            
          
        
      
    
    
      
        }
      
    
  
   







 













  
    
      
        
          
            l
            ++
          
          ;
        
      
    
    
      
        
          
            Psum
            =
            
              
                ∑
                i
              
              ⁢
              
                (
                
                  
                    
                      n
                      i
                    
                    
                      e
                      i
                    
                  
                  ⁢
                  s
                  *
                  
                    (
                    
                      
                        
                          
                            w
                            i
                          
                          ⁢
                          
                            
                          
                          ⁢
                          
                            e
                            i
                          
                        
                        
                          x
                          ⁡
                          
                            [
                            l
                            ]
                          
                        
                      
                      ,
                      
                        
                          s
                          i
                        
                        ⁡
                        
                          (
                          
                            n
                            i
                          
                          )
                        
                      
                    
                    )
                  
                
                )
              
            
          
          ;
        
      
    
    
      
        }
      
    
  
   







 









lambda = Ppossum/(P − Pmaxsum);



it (lambda > x[l−1] or lambda > x[l]) {









error!








}


else{









return (lambda)



}







}









  where
  ⁢
  
    
  
  ⁢
  s
  *
  
    (
    
      
        
          
            w
            i
          
          ⁢
          
            e
            i
          
        
        λ
      
      ,
      
        
          s
          i
        
        ⁡
        
          (
          
            n
            i
          
          )
        
      
    
    )
  
  ⁢
  
    
  
  ⁢
  is
  ⁢
  
    
  
  ⁢
  defined
  ⁢
  
    
  
  ⁢
  in
  ⁢
  
    
  
  ⁢
  equation
  ⁢
  
    
  
  ⁢
  
    
      (
      13
      )
    
    .
  










2.1.3.1 Per User Equality Constraints

If for some user i, the inequality pi≦eisi(ni)ni is replaced by the equality constraint pi=eisi(ni)ni, as may happen for instance in a retransmission when the rate is fixed, we may simply remove this user from the problem after subtracting pi from P and proceed as before.
2.1.3.2 No Per User Power Constraints
For the case that si(ni)=∞, the following simpler algorithm finds λ*(n). First, without loss of generality, assume that the users are numbered in descreasing order of wiei. Calculate the following




  
    
      
        
          
            λ
            ~
          
          j
        
        =
        
          
            
              ∑
              
                i
                =
                1
              
              j
            
            ⁢
            
              
                w
                i
              
              ⁢
              
                n
                i
              
            
          
          
            P
            +
            
              
                ∑
                
                  i
                  =
                  1
                
                j
              
              ⁢
              
                
                  n
                  i
                
                
                  e
                  i
                
              
            
          
        
      
    
    
      
        ∀
        
          j
          ∈
          
            {
            
              1
              ,
              2
              ,
              ...
              ⁢
              
                
              
              ,
              M
            
            }
          
        
      
    
  




We determine λ*(n) as follows:

1. Set j=1.
2. While wj+1ej+1>{tilde over (λ)}j, j++
3. λ*={tilde over (λ)}j 
2.1.4 Step 209, Obtaining L*.
Any algorithm that minimizes or attempts to minimize L(λ) over λ is considered here. In the preferred embodiment we do so iteratively, where in each step k of the iteration we narrow the range [λkLB,λkUB] of the optimal λ* in a manner such that starting at k=0 with 0≦λ0LB≦λ0UB<∞ and for some d≧1 and 0≦ρ<1,

[λ(k+1)dUB−λ(k+1)dLB]≦ρ[λkdUB−λkdLB] ∀k≧0.

A plurality of such schemes may be designed all of which guarantee geometrically fast convergence to the optimal λ*. Two such embodiments are described below.
2.1.4.1 First Embodiment for Finding λ*
The algorithm makes use of the functions L(λ) (11), n*(λ) (18) and the tie resolution, λ*(n) (20), p*(n) (21), and V(p,n) (4) defined earlier. The function r(p,n) is simply the rate given the powers and codes given in (2). Pseudo-code for calculating λ*(n) is also given in Step 213.
In “Joint scheduling and resource allocation in CDMA systems,” by R. Agrawal, V. Subramanian, R. Berry, G. Casheekar, A. Diwan, B. Love, it was shown that L(λ) is convex and that the optimal λ*=argminλ≧0L(λ)ε[λmin,λmax] where λmin=0 and λmax=maxiwiei.
At the kth iteration we identify λ* in the range [λkLB,λkUB] with the estimate of λ* given by λk*. The state of the algorithm at any time k is given by

Sk={[λkLB,LkLB], [λk*,Lk*,nk*], [λkUB,LkUB]}

with the assumption that Lk*=L(λk*)≦min (LkUB=L(λkUB),LkLB=L(λkLB)).

Step 0 initializes the state of this algorithm and provides an exit check in case we got lucky to hit the optimal allocation.
Step 1 does the iteration on the above state of the algorithm and also uses an exit check.
Step 2 polishes up by taking additional constraints into account and reoptimizing the powers, calculating rates/TBS etc.
The algorithm works as follows.
Step 0: Initialize

    
    
        (a) λ0LB=0
        (b) If there are no per user power constraints on at least one user then L(λ0LB)=+∞.
        (c) Else calculate L(λ0LB).
        (d) Sort users in decreasing order of wiei.
        (e) Find smallest j* such that
    
    






  
    
      ∑
      
        i
        =
        1
      
      
        
          j
          *
        
        -
        1
      
    
    ⁢
    
      N
      i
    
  
  <
  N
  ≤
  
    
      ∑
      
        i
        =
        1
      
      
        j
        *
      
    
    ⁢
    
      N
      i
    
  




    
    
        (f) Define n0*
    
    






  
    n
    
      0
      ,
      i
    
    *
  
  =
  
    {
    
      
        
          
            N
            i
          
        
        
          
            i
            <
            
              j
              *
            
          
        
      
      
        
          
            N
            -
            
              
                ∑
                
                  i
                  =
                  1
                
                
                  j
                  -
                  1
                
              
              ⁢
              
                N
                i
              
            
          
        
        
          
            i
            =
            
              j
              *
            
          
        
      
      
        
          0
        
        
          
            i
            >
            
              j
              *
            
          
        
      
    
  




    
    
        (g)In case of a tie for j pick the user with the larger wi and if the wis are also equal, pick either.
        (h) If nj,0=Nj* then
    
    






  
    P
    req
  
  =
  
    
      ∑
      
        i
        =
        1
      
      
        j
        *
      
    
    ⁢
    
      
        
          n
          
            i
            ,
            0
          
        
        
          e
          i
        
      
      ⁢
      
        min
        ⁡
        
          (
          
            
              (
              
                
                  
                    
                      w
                      i
                    
                    ⁢
                    
                      e
                      i
                    
                  
                  
                    
                      w
                      
                        
                          j
                          *
                        
                        +
                        1
                      
                    
                    ⁢
                    
                      e
                      
                        
                          j
                          *
                        
                        +
                        1
                      
                    
                  
                
                -
                1
              
              )
            
            ,
            
              s
              i
            
          
          )
        
      
    
  




    
    
        (i) Else
    
    






  
    P
    req
  
  =
  
    
      ∑
      
        i
        =
        1
      
      
        j
        *
      
    
    ⁢
    
      
        
          n
          
            i
            ,
            0
          
        
        
          e
          i
        
      
      ⁢
      
        min
        ⁡
        
          (
          
            
              (
              
                
                  
                    
                      w
                      i
                    
                    ⁢
                    
                      e
                      i
                    
                  
                  
                    
                      w
                      
                        j
                        *
                      
                    
                    ⁢
                    
                      e
                      
                        j
                        *
                      
                    
                  
                
                -
                1
              
              )
            
            ,
            
              s
              i
            
          
          )
        
      
    
  




    
    
        (j) If Preq≧P, then go to Step 2.
        (k) If nj,0*=Nj* then λ0UB=wj+1*ej+1*, else λ0UB=wj*ej*.
        (l) Calculate L0UB=L(λ0UB).
        (m) If L0LB≦L0UB, then λ0*=λ0LB; L0*=L0B.
        (n) Else λ0*=λ0UB; L0*=L0UB.
    
    


Step 1: Iterate For ( k=0, k<iteration limit, k++)

    
    
        (a) If Lk*>min(LkLB,LkUB), then error!
        (b) Calculate λk+1CAND=λ*(nk*))
        (c) Calculate Lk+1CAND=L(λk+1CAND), nk+1CAND=n*(λk+1CAND).
        (d) Calculate λ*(nk+1CAND), pk+1CAND=p*(nk+1CAND)
        (e) Calculate V(nk+1CAND).
        (f) If V(nk+1CAND)>(1−[epsilon])min{Lk+1CAND,Lk*)}, then go to Step 2.
        (g) If Lk+1CAND<Lk* and λk+1CAND>λkLB+[epsilon](λkUB−λkLB) and λk+1CAND<λkUB−[epsilon](λkUB−λkLB) and λk+1CAND≠λk*
        TRY FASTER TRACK
        
            i. If f λk+1CAND<λk*

λk+1UB=λk*

λk+1*=λk+1CAND 

λk+1LBλkLB 

            ii. Else

λk+1LB=λk*

λk+1*=λk+1CAND 

λk+1UB=λkUB 

        
        
        (h) Else
        DO BISECTION
        
            i. If λk*−λkLB≧λkUB−λk* then
            
                A. Assign

λk+1CAND=(λkLB+λk*)/2

                B. Calculate

Lk+1CAND=L(λk+1CAND), nk+1CAND=n*(λk+1CAND).

                C. Calculate

λ*(nk+1CAND), pk+1CAND=p*(nk+1CAND)

                D. Calculate

V(nk+1CAND).

                E. If V(nk+1CAND)>(1−[epsilon])min{Lk+1CAND, Lk*)}, then go to Step 2.
                F. If Lk+1CAND≦Lk*, then change the algorithm state as follows

λk+1UB=λk*

Lk+1UB=Lk*

λk+1*=λk+1CAND 

Lk+1*=Lk+1CAND 

nk+1*=nk+1CAND 

λk+1LB=λkLB 

Lk+1LB=LkLB 

                G. Else change as follows

λk+1LB=λk+1CAND 

Lk+1LB=Lk+1CAND 

λk+1*=λk*

Lk+1*=Lk*

nk+1*=nk*

λk+1UB=λk+1UB 

Lk+1UBLkUB 

            
            
            ii. Else
            
                A. Assign

λk+1CAND=(λkUB+λk*)/2

                B. Calculate

Lk+1CAND=L(λk+1CAND), nk+1CAND=n*(λk+1CAND).

                C. Calculate

λ*(nk+1CAND), pk+1CAND=p*(nk+1CAND)

                D. Calculate

V(nk+1CAND).

                E. If V(nk+1CAND)>(1−[epsilon])min{Lk+1CAND,Lk*)}, then go to Step 2.
                F. If Lk+1CAND≦Lk*, then change the algorithm state as follows

λk+1LB=λk*

Lk+1LB=Lk*

λk+1*=λk+1CAND 

L*=Lk+1CAND 

nk+1*=nk+1CAND 

λk+1UB=λkUB 

Lk+1UB=LkUB 

                G. Else change as follows

λk+1LB=λk+1LB 

Lk+1LB=Lk+1LB 

λk+1*=λk*

Lk+1*=Lk*

nk+1*=nk*

λk+1UB=λk+1CAND 

Lk+1CAND=Lk+1CAND 

            
            
        
        
    
    


Step 2:

    
    
        (a) Round n*—note two users may have non-integer allocations in the case of tie. In that case round down the one with the greater power per code requirement and round up the other one.
        (b) Recalculate p*(n*) taking all constraints including rate constraints into account.
        (c) Calculate the rate r*=r(p*,n*) given by
    
    






  
    r
    i
    *
  
  =
  
    
      240000
      
        ln
        ⁢
        
          
        
        ⁢
        2
      
    
    ⁢
    
      n
      i
      *
    
    ⁢
    
      
    
    ⁢
    
      ln
      ⁡
      
        (
        
          1
          +
          
            
              
                p
                i
                *
              
              ⁢
              
                e
                i
              
            
            
              n
              i
              *
            
          
        
        )
      
    
  




and TBS=ri×0.002. Round down to nearest byte or some even coarser quantization.

We can also skip steps (b)-(g) in Step 1 to get a pure bisection based search algorithm.

2.1.4.2 Second Embodiment for Finding λ*

The second embodiment for finding the optimal λ* uses subgradients of L(λ) to aid in its minimization. For any given λ, a subgradient can easily be found as follows:

    
    
        1. First find n*(λ) in equation (18). In case of a “tie” all feasible code allocations which satisfy the sum power constraint with equality and optimize the Lagrangian (as described after equation (18)) are considered.
        2. Next, using n*(λ) find the corresponding p* as given by equation (12)
        3. Then
    
    






  P
  -
  
    
      ∑
      i
      
        
      
    
    ⁢
    
      
    
    ⁢
    
      p
      i
      *
    
  




is a subgradient to L(λ) at λ.

    
    
        4. Since L(λ) is convex, λ* will be optimal if and only if 0 is a subgradient of L(λ*).
        5. Thus, we can find the optimal λ* that minimizes L(λ) by numerically searching for λ with a 0 subgradient.

2.2 Other Embodiments

    
    


Based on the above results scheduler/optimizer 101 determines appropriate values for r, n, and p as follows:

    
    
        1. Collect all the input parameters P, N, N, R, R/N, P, S, e, W, Q, c, b. (Step 301)
        2. Calculate n. (Step 303)
        3. Calculate optimal p and r keeping n fixed. (Step 305)
    
    


This is illustrated in FIG. 3, where FIG. 3 is a flow chart showing operation of scheduler/optimizer 101 in accordance with another embodiment of the present invention. The logic flow begins at step 301 where P, N, N, R, R/N, P, S, e, W, Q, c, and b are collected by the optimizer 101. Note that steps 2-5 in the first embodiment were really aids to calculating the optimal n. We consider any other method to calculate n based on the input parameters P, N, N, R, R/N, P, S, e, W, W, Q, c, and b (Step 303). Then, r and p are calculated keeping n fixed (step 305). In particular n is fixed to the value obtained in Step 303, and p and r are calculated as per equations (21) and (2) taking the actual rate constraint R into account. Finally, at step 307 values for n, p and r are output to controller 103 and utilized to schedule and transmit data via transmitters 105.
An alternative method of calculating n based on the input parameters e, P, N, N, and S, is presented below:

    
    
        1. Sort users based on any metric that is a function of the input parameters including wi and ei.
        2. Find smallest j* such that
    
    






  
    
      ∑
      
        i
        =
        1
      
      
        
          j
          *
        
        -
        1
      
    
    ⁢
    
      
    
    ⁢
    
      N
      i
    
  
  <
  N
  ≤
  
    
      ∑
      
        i
        =
        1
      
      
        j
        *
      
    
    ⁢
    
      
    
    ⁢
    
      N
      i
    
  




    
    
        3. Define n0 
    
    






  
    n
    
      0
      ,
      i
    
    *
  
  =
  
    {
    
      
        
          
            N
            i
          
        
        
          
            i
            <
            
              j
              *
            
          
        
      
      
        
          
            N
            -
            
              
                ∑
                
                  i
                  =
                  1
                
                
                  j
                  -
                  1
                
              
              ⁢
              
                
              
              ⁢
              
                N
                i
              
            
          
        
        
          
            i
            =
            
              j
              *
            
          
        
      
      
        
          0
        
        
          
            i
            >
            
              j
              *
            
          
        
      
    
  




    
    
        4. In case of a tie for j* pick the user with the larger wi and if the wis are also equal, pick either.
        5. Optionally, we can also run one or more iteration of the algorithm described in the previous section.
    
    


While the invention has been particularly shown and described with reference to particular embodiments, it will be understood by those skilled in the art that various changes in form and details may be made therein without departing from the spirit and scope of the invention. For example, although examples where given above with respect to implementations within an HSDPA system, one of ordinary skill in the art will recognize that the above embodiments may be implanted in any communication system where codes and/or power need to be allocated. It is intended that such changes come within the scope of the following claims.

## Claims

1. A method for resource allocation, the method comprising:
receiving, at a scheduler, a maximum total system transmit power (P);
receiving, at a scheduler, a maximum number of system codes available (N);
receiving, at a scheduler, a maximum number of codes for each user in the system (N);
receiving, at a scheduler, a maximum SINR value (S) for each user in the system;
receiving, at a scheduler, a SINR per watt of transmit power value for each user in the system (e);
determining an optimal number of codes per user (n) and optimal power levels per user (p) based on P, N, N, S, and e comprising maximizing a dot product of a weight vector as a function of a throughput/queue length wt=(w1(W1,tQ1,t), . . . , wd (Wd,tQd,t)) and a rate vector rt to be selected at a scheduling time t, where:
wt=(w1,t, . . . , wd,t) is a weight vector,
wt=(w1,t, . . . , wd,t) is a vector of estimates of user throughputs,
Qt=(Q1,t, . . . , Qd,t) is the vector of user queue lengths or delays,
rt=(r1,t, . . . , rd,t) is a rate vector selected, and d is the number of users; and
scheduling, at a scheduler, users with operating parameters based on n and p.

2. The method of claim 1 further comprising determining an optimal rate for each user (r) based on n and p.

3. The method of claim 1 wherein determining n and p comprises maximizing a dot product of a weight vector as a function of a throughput/queue length wt=(w1(W1,tQ1,t), . . . , wd(Wd,tQd,t)) and a rate vector rt to be selected at a scheduling time t, where:
wt=(w1,t, . . . , wd,t) is a weight vector,
Wt=(W1,t, . . . , Wd,t) is a vector of estimates of user throughputs,
Qt=(W1,t, . . . , Qd,t) is the vector of user queue lengths or delays,
rt=(r1,t, . . . , rd,t) is a rate vector selected, and
d is the number of users.

4. A method for resource allocation, the method comprising:
receiving, at a scheduler, a maximum total system transmit power (P);
receiving, at a scheduler, a maximum number of system codes available (N);
receiving, at a scheduler, a maximum number of codes for each user in the system (N);
receiving, at a scheduler, a maximum SINR value (S) for each user in the system;
receiving, at a scheduler, a SINR per watt of transmit power value for each user in the system (e);
determining, at a scheduler, an optimal number of codes per user (n) and optimal power levels per user (p) based on P, N, N, S, and e comprising the step of determining:


V*:=max(n,p)εχV(n,p)



subject to




  
    
      
        
          
            ∑
            i
            
              
            
          
          ⁢
          
            
          
          ⁢
          
            n
            i
          
        
        ≤
        N
      
    
  
  
    
      
        
          
            ∑
            i
            
              
            
          
          ⁢
          
            
          
          ⁢
          
            p
            i
          
        
        ≤
        P
      
    
  
  
    
      where
    
  
  
    
      
        
          V
          ⁡
          
            (
            
              n
              ,
              p
            
            )
          
        
        :=
        
          
            ∑
            i
            
              
            
          
          ⁢
          
            
          
          ⁢
          
            
              w
              i
            
            ⁢
            
              n
              i
            
            ⁢
            
              ln
              ⁡
              
                (
                
                  1
                  +
                  
                    
                      
                        p
                        i
                      
                      ⁢
                      
                        e
                        i
                      
                    
                    
                      n
                      i
                    
                  
                
                )
              
            
          
        
      
    
  
  
    
      
        
          χ
          :=
          
            {
            
              
                
                  
                    (
                    
                      n
                      ,
                      p
                    
                    )
                  
                  ≥
                  0
                
                :
                
                  
                    n
                    i
                  
                  ≤
                  
                    N
                    i
                  
                
              
              ,
              
                
                  p
                  i
                
                ≤
                
                  
                    S
                    i
                  
                  ⁢
                  
                    n
                    i
                  
                  ⁢
                  
                    /
                  
                  ⁢
                  
                    e
                    i
                  
                  ⁢
                  
                    
                  
                  ⁢
                  
                    ∀
                    i
                  
                
              
            
            }
          
        
        ,
      
    
  



w is the vector of weights wis,
e is the vector of SINR per watt of transmit power eis,
S is the vector of maximum SINR Sis,
wi=ƒi(Wi, Qi),and

where
W=(W1, . . . , Wd) is estimated throughput vector for all the users,
Q=(Q1, . . . , Qd) is queue length or delay vector for all the users, and
ƒi is some function of the throughput and/or queue length for user i and it depends on the QoS class and parameters for user i.

5. The method of claim 4 further comprising determining an optimal rate for each user (r) based on n and p.

6. A method for resource allocation, the method comprising:
determining, at a scheduler, a value for an optimal number of codes per user (n) within a communication system comprising calculating n=n*(λ*, μ*(λ*)) where
λ* is an optimal Lagrange multiplier for a power constraint;
μ*(λ) is a optimal Lagrange multiplier μ for a code constraint (as a function of the Langrange multiplier for the power constraint λ), and
n* (λ, μ) is an optimal code allocation as a function of λ, μ; and
determining, at a scheduler, an optimal rate per user (r) and an optimal power per user (p) based on n.

7. The method of claim 6 wherein the step of determining the value for n, comprises the step of receiving a pre-determined value for n.

8. A method for resource allocation, the method comprising:
determining, at a scheduler, a value for an optimal number of codes per user (n) within a communication system; and
determining, at a scheduler, an optimal rate per user (r) and an optimal power per user (p) based on n comprising the step of:
calculating n=p*(n)=p*(n, λ* (n));

where
λ*(n) is an optimal Lagrange multiplier for the power constraint; and
p*(n, λ) is the optimal power allocation as a function of n, λ.

9. The method of claim 8 wherein the step of determining the value for n, comprises the step of receiving a pre-determined value for n.

10. A method of resource allocation, the method comprising:
determining, at a scheduler, a value for n, comprising the steps of:
sorting, at a scheduler, users in descending order based on a metric that is a function of wi and ei, where ei is a SINR per watt of transmit power value and wi is the gradient/weight for each user i in the system;
determining, at a scheduler, a smallest j* such that





  
    
      ∑
      
        i
        =
        1
      
      
        
          j
          *
        
        -
        1
      
    
    ⁢
    
      
    
    ⁢
    
      N
      i
    
  
  <
  N
  ≤
  
    
      ∑
      
        i
        =
        1
      
      
        j
        *
      
    
    ⁢
    
      
    
    ⁢
    
      N
      i
    
  



determining, at a scheduler, n such that





  
    n
    i
  
  =
  
    {
    
      
        
          
            
              N
              i
            
          
          
            
              i
              <
              
                j
                *
              
            
          
        
        
          
            
              N
              -
              
                
                  ∑
                  
                    i
                    =
                    1
                  
                  
                    j
                    -
                    1
                  
                
                ⁢
                
                  
                
                ⁢
                
                  N
                  i
                
              
            
          
          
            
              i
              =
              
                j
                *
              
            
          
        
        
          
            0
          
          
            
              i
              >
              
                j
                *
              
            
          
        
      
      ,
    
  




and
determining, at a scheduler, an optimal rate per user (r) and an optimal power per user (ii) based on n.

11. An apparatus comprising:
a scheduler receiving a maximum total system transmit power (P), a maximum number of system codes available (N), a maximum number of codes for each user in the system (N), a maximum SINR value (S) for each user in the system, and a SINR per watt of transmit power value for each user in the system (e), the scheduler outputting an optimal number of codes per user (n) and optimal power levels per user (p) based on P, N, N, S, and e and wherein n and p are determined by maximizing a dot product of a weight vector as a function of the throughput/queue length wt=(w1(W1,tQ1,t), . . . , wd(Wd,tQd,t)) and a rate vector rt to be selected at a scheduling time t, where:
wt=(w1,t, . . . , wd,t) is a weight vector,
Wt=(W1,t, . . . , Wd,t) is a vector of estimates of user throughputs,
Qt=(Q1,t, . . . , Qd,t) is the vector of user queue lengths,
rt=(r1,t, . . . , rd,t) is a rate vector selected and d is the number of users.

12. The apparatus of claim 11 further comprising:
a controller scheduling transmissions to users with physical layer operating points based on n and p.

13. An apparatus comprising:
a scheduler receiving a maximum total system transmit power (P), a maximum number of system codes available (N), a maximum number of codes for each user in the system (N), a maximum STNR value (S) for each user in the system, and a SINR per watt of transmit power value for each user in the system (e), the scheduler outputting an optimal number of codes per user (n) and optimal power levels per user (p) based on P, N, N, S, and e and wherein n and p determined by computing:


V*:=max(n,p)εχV(n,p)



subject to




  
    
      
        
          
            ∑
            i
            
              
            
          
          ⁢
          
            
          
          ⁢
          
            n
            i
          
        
        ≤
        N
      
    
  
  
    
      
        
          
            ∑
            i
            
              
            
          
          ⁢
          
            
          
          ⁢
          
            p
            i
          
        
        ≤
        P
      
    
  
  
    
      where
    
  
  
    
      
        
          V
          ⁡
          
            (
            
              n
              ,
              p
            
            )
          
        
        :=
        
          
            ∑
            i
            
              
            
          
          ⁢
          
            
          
          ⁢
          
            
              w
              i
            
            ⁢
            
              n
              i
            
            ⁢
            
              ln
              ⁡
              
                (
                
                  1
                  +
                  
                    
                      
                        p
                        i
                      
                      ⁢
                      
                        e
                        i
                      
                    
                    
                      n
                      i
                    
                  
                
                )
              
            
          
        
      
    
  
  
    
      
        
          χ
          :=
          
            {
            
              
                
                  
                    (
                    
                      n
                      ,
                      p
                    
                    )
                  
                  ≥
                  0
                
                :
                
                  
                    n
                    i
                  
                  ≤
                  
                    N
                    i
                  
                
              
              ,
              
                
                  p
                  i
                
                ≤
                
                  
                    S
                    i
                  
                  ⁢
                  
                    n
                    i
                  
                  ⁢
                  
                    /
                  
                  ⁢
                  
                    e
                    i
                  
                  ⁢
                  
                    
                  
                  ⁢
                  
                    ∀
                    i
                  
                
              
            
            }
          
        
        ,
      
    
  



e is the vector of SINR per watt of transmit power eis,
wi=ƒi(Wi, Qi), and

where
W=(W1, . . . , Wd) is estimated throughput vector for all the users,
Q=(Q1, . . . , Qd) is queue length vector for all the users, and
ƒi is a function of a throughput and/or queue length for user i.

14. The apparatus of claim 13 further comprising:
a controller scheduling transmissions to users with physical layer operating points based on n and p.