# Patent

## Title
Power controlled multiple access (PCMA) in wireless communication networks

## Abstract

An approach for managing data transmissions from multiple sources using a common channel addresses the problem of interference caused by two or more sources transmitting simultaneously. In one embodiment, the communication system provides a state of the channel, for example, an indication of the recent or current channel state such as interference level. Before transmitting, a transmitter station buffers blocks of data and selects a transmission mode for use in transmitting at least one of the buffered data blocks as a function of the buffered data sets and the indication of the recent channel state (interference). More specific embodiments are directed to, among other aspects, use of algorithms for evaluating the channel state and processing the transmissions using various types of transmission modes including, for example, setting the power level, modulation scheme, access point, coding scheme, and combinations of these adjustable parameters.

## Background
RELATED PATENT DOCUMENTS
This patent document claims the benefit, under 35 U.S.C. § 119(e), of U.S. Provisional Application Ser. No. 60/249,118, filed on Nov. 15, 2000, and Ser. No. 60/257,680, filed on Dec. 22, 2000.


FIELD OF THE INVENTION
The present invention relates generally to data communication systems and methods and, more particularly, to systems and methods for processing of packetized data in network environments including, for example, wireless networks.
BACKGROUND OF THE INVENTION
Controlling the transmitter powers in wireless communication networks provides multiple benefits. It allows interfering links sharing the same radio channel to achieve required quality of service (QoS) levels, minimizing the power spent in the process and extending the battery life of mobile users. Moreover, by judiciously using power to achieve their QoS goals, interference is mitigated and the network capacity increases. The benefits of power control have attracted substantial research attention. Most of the research, however, has focused on voice-oriented ‘continuous’ traffic, which is dominant in current generation wireless networks.
Next generation wireless networks are currently being designed to support intermittent packetized data traffic, beyond the standard voice-oriented continuous one. Such support is needed for the delivery of sophisticated information services over tetherless wireless channels (for example, Web browsing on a mobile laptop computer). The problem of power control in this new environment of packetized data traffic is not well understood. Early preliminary studies have not addressed several important aspects of the problem.
The transmitter faces the following problem in controlling its power. When the transmitter observes high interference in the channel, it recognizes that it will have to spend a lot of power (actually energy) to overcome the interference and transmit a packet successfully to the receiver. Therefore, it would be better to back off, buffer the traffic and wait for the interference to subside before it transmits to clear the buffer. However, as it has backed off, the buffer is filling up with new packet arrivals and delay rises, which pushes the transmitter to become power-aggressive in order to reduce its backlog. There are many transmitters sharing the channel, each one observing only its local interference (at its intended receiver) and its backlog level. The interference is responsive to transmitter actions. Indeed, a power-aggressive transmitter may cause some other to go into a backoff mode or become also aggressive. For voice-oriented continuous traffic the previous situation cannot be a dominant one, since only minimal ‘elastic’ buffering can be tolerated due to the delay-sensitive nature of the traffic.
SUMMARY
Various embodiments of the present invention are directed to overcoming the above mentioned deficiencies and to power controlled shared channel access in wireless networks supporting packetized channel traffic beyond the voice-oriented continuous traffic primarily supported by current generation networks.
Other embodiments of the present invention are directed to approaches for managing data transmissions from multiple sources using a common channel (or overlapping channels) to alleviate the problem of interference caused by two or more sources transmitting simultaneously. In one more specific embodiment, for example, the communication system provides a state of the channel, for example, an indication of the recent or current channel state such as interference level. Before transmitting, a transmitter station buffers blocks of data and selects a transmission mode for use in transmitting at least one of the buffered data blocks as a function of the buffered data sets and the indication of the recent channel state (interference). Other more specific embodiments are directed to, among other aspects, use of algorithms for evaluating the channel state and processing the transmissions using various types of transmission modes including, for example, setting the power level, modulation scheme, access point, coding scheme, and combinations of these adjustable parameters.
Other aspects of the invention are directed to PCMA protocols for autonomous channel access in high-performance wireless networks, and to methods, systems and components in such systems operating consistent with the above approaches for managing data transmissions from multiple sources.
The above summary is not intended to characterize every aspect, or each embodiment, contemplated in connection with the present invention. Other aspects and embodiments will become apparent from the discussion in connection with the figures which are introduced below and the detailed description of the various embodiments.



BRIEF DESCRIPTION OF THE DRAWINGS
Various aspects and advantages of the present invention will become apparent upon reading the following detailed description of various embodiments and upon reference to the drawings in which:
FIG. 1 shows plots of the power function
p*(i)=√{square root over ((Xi)−i,iε[0,1000])} of (6), for α=β=1 and I=100, for various values of X=200, 400, 600, 800, 1000, 15000, 25000, 3000, 35000 correspondingly (the lowest curve is for X=200 and the highest for X=3500). This is the same for any distribution of the random interference.
FIG. 2 is a plot of the average power function p*avg of (12), as a function of X, for α=β=1 and I=100. This is specific to uniform interferences in [0,100].
FIG. 3 shows plots of the power function




  
    
      p
      *
    
    ⁡
    
      (
      i
      )
    
  
  =
  
    
      -
      i
    
    ⁢
    
      
    
    ⁢
    
      log
      ⁡
      
        (
        
          i
          X
        
        )
      
    
  




in (40) for iε[0,1000], where δ=1 and I=1000, for different values of X=200, 400, 600, 800, 1000, 1500, 2000, 2500, 3000, 3500 correspondingly (the lowest curve is for X=200 and the highest for X=3500).

FIG. 4 shows plots of the average backlog vs. average load (arrival rate λ) performance curves for a wireless network topology (see text) operating under the three power control algorithms: 1) Constant-SIR (vertical bar marks) 2) PCMA-1 (asterisk marks) and 3) PCMA-2 (cross marks). Note that the maximal throughput of Constant-SIR is about 4.1, while both PCMA-1 and PCMA-2 show a maximal throughput of about 5.2, that is, a 20% improvement over Constant-SIR.
FIG. 5 is an example embodiment of a system, according to the present invention, for managing data transmissions from multiple sources using a common channel (or overlapping channels) to alleviate the problem of interference caused by two or more sources transmitting simultaneously.



While the invention is amenable to various modifications and alternative forms, specifics thereof have been shown by way of example in the drawings and will be described in detail. It should be understood, however, that the intention is not to limit the invention to the particular embodiment described. On the contrary, the intention is to cover all modifications, equivalents, and alternatives falling within the spirit and scope of the invention as defined by the appended claims.
DETAILED DESCRIPTION
The present invention is believed to be applicable to a variety of systems and methods that communicate data blocks (sometimes known as “packets” depending on the application) in a communication environment that is susceptible to interference from neighboring packet transmissions. In connection with wireless LAN communications systems, for example, multiple transmitters in the system transmit data packets at approximately the same time on a common channel or nearby channels. An appreciation of the invention may be ascertained through the following discussion in the context of such example applications, in which those skilled in the art will appreciate that reference to a “data block” or “packet” is not necessarily limited to a data set having a size that is fixed.
A first example embodiment of the present invention is directed to a wireless LAN communications system coupled, for example, to the Internet and related terminals. FIG. 5 illustrates this type of system. In various embodiments, one or more of the illustrated base stations 110-1 through 110-N of FIG. 5 include: a first data processing block adapted to provide an indication of recent state for the channel; a second data processing block adapted to buffer blocks of data for subsequent transmission; and a third data processing block adapted to select a transmission mode for use in transmitting at least one of the buffered data blocks as a function of the buffered data sets and the indication of the recent channel state. The recent channel state can correspond to the interference level in the system, for example, via an interference level detection block (ILD 110). Before transmitting, the base station (which includes a transmitter 120 and in some applications also includes a receiver 122 for receiving data from the mobiles) buffers blocks of data, for example, in memory 124 and the base station's processor (e.g., 130), and selects a transmission mode for use in transmitting at least one of the buffered data blocks as a function of the buffered data sets and the indication of the recent channel state (interference). As described later and in the attached Appendices A and B, other more specific embodiments are directed to, among other aspects, use of algorithms for evaluating the channel state and processing the transmissions using various types of transmission modes including, for example, setting the power level, modulation scheme, access point, coding scheme, and combinations of these adjustable parameters.
In reviewing the following discussion, this system example may be referred to for an understanding of one or many example applications of the present invention.
Using for example the framework of Dynamic Programming or Bellman's principle of optimality, a single communication link operating in a channel with a random (i.i.d. or Markovian) interference is addressed, according to one aspect of the invention by efficiently channel-sharing based on algorithms that employ selection of channel-related parameters such as power level, modulation scheme, access point, and a coding scheme. Various embodiments of the present invention are directed to a number of progressively more-complicated formulations of the power control problem, incorporating various relevant operations costs (power, delay, packet loss, deadlines, etc.) which typically map to the link's quality of service and turn out to be important in practice.
It is assumed that the interference environment is non-responsive; that is, the interference does not react to changes in transmission power and is insensitive to transmitter actions. In essence, the power control problem is for a single link in a channel with randomly modulated interference. This approach is readily extended for the more realistic case of multiple links in the channel, interfering with each other. This is the case of “responsive” interference as is discussed below.
A. Optimally Emptying the Transmitter Buffer Under i.i.d. Interference—Static Formulation
Consider a communication link operating in slotted time, indexed by ηε{1, 2, 3, . . . }. the transmitter is equipped with a FIFO queue (buffer) which initially holds K packets, indexed by kε{1, 2, 3, . . . K}. Packet 1 is that at the head of the queue and packet K at the tail. Packets are transmitted over a channel of random interference. Let in be the interference during the nth time slot. This stays constant during each time slot, but fluctuates randomly in different ones. Let us assume that the random variables in are independent in different time slots and identically distributed over the interval [0,I] with distribution density f(i). For example, they could be uniformly distributed over [0,I].
Let pn be the power that the transmitter uses to transmit a packet during the nth time slot. If the channel interference is i and power p is used to transmit a packet in a time slot, then that is successfully received at the receiver with probability s(p,i). Packet transmission events are statistically independent of each other. Upon successful transmission, the packet is immediately removed from the queue and the transmitter attempts to transmit the next one in the queue. In case of unsuccessful transmission, the transmitter continues to attempt transmission of the same packet in the following time slots, until this is successfully transmitted. We assume that the transmitter is immediately notified at the end of each slot, whether the packet transmitted in that slot was successfully received or not, through some highly reliable ACK/NACK process which takes negligible time. Finally, we denote by bn the backlog (number of packets in the transmitter queue) in the nth time slot. Assume that the transmitter first estimates the interference in at the beginning of the nth time slot, then selects a power pn to transmit the head packet, and if successful, removes the packet from the queue at the end of the current time slot.
The issue is to choose the power pn at which to transmit the head packet given: 1) the current interference level in and, 2) the current backlog bn. In each time slot n the system incurs a cost that has two components: the power cost pn, that refers to the power (actually energy) spent in the slot; and the backlog cost B(bn), where B( ) is an increasing, positive function of the number of packets in the buffer.
The system is allowed to evolve up to time N and is then stopped at the beginning of slot N+1, incurring a terminal cost T(bN=1) which is a positive, increasing function of the packets that have been left in the buffer. The overall cost of the problem is the sum of all the individual costs incurred in the time slots plus the terminal one. The objective is to minimize the average overall cost by controlling the powers {p1, p2, . . . pn, . . . pN} in consecutive time slots; that sequence is the power control applied.
The above formulation of the problem is within the general framework of dynamic programming. Recalling that the interference is i.i.d. in different time slots, let Jn(b) be the average cost-to-go at time n, that is, the minimal expected cost that would be incurred under optimal power control, if the system were to evolve from time n to N, starting at time n with b jobs in the queue. The standard dynamic programming recursion satisfied by Jn(b) becomes in this case:




  
    
      
        
          
            J
            n
          
          ⁡
          
            (
            b
            )
          
        
        =
        
          
            inf
            p
          
          ⁢
          
            
              ∫
              0
              I
            
            ⁢
            
              
                {
                
                  p
                  +
                  
                    B
                    ⁡
                    
                      (
                      b
                      )
                    
                  
                  +
                  
                    
                      s
                      ⁡
                      
                        (
                        
                          p
                          ,
                          i
                        
                        )
                      
                    
                    ⁢
                    
                      
                        J
                        
                          n
                          +
                          1
                        
                      
                      ⁡
                      
                        (
                        
                          b
                          -
                          1
                        
                        )
                      
                    
                  
                  ⁢
                  
                    
                  
                  +
                  
                    
                      (
                      
                        1
                        -
                        
                          s
                          ⁡
                          
                            (
                            
                              p
                              ,
                              i
                            
                            )
                          
                        
                      
                      )
                    
                    ⁢
                    
                      
                        J
                        
                          n
                          +
                          1
                        
                      
                      ⁡
                      
                        (
                        b
                        )
                      
                    
                  
                
                }
              
              ⁢
              
                f
                ⁡
                
                  (
                  i
                  )
                
              
              ⁢
              
                d
                i
              
            
          
        
      
    
    
      
        (
        1
        )
      
    
  




    
    
        where f(i) is the density of the i.i.d. interference. Indeed, note that the immediately incurred cost is p+B(b), and with probability s(p,i) a packet will depart and the future cost-to-go will be Jn+1(b−1), while with probability (1−s(p,i)) no packet will depart and the future cost-to-go will be Jn+1(b). Rearranging the terms, we get
    
    






  
    
      
        
          
            
              J
              n
            
            ⁡
            
              (
              b
              )
            
          
          =
          
            
              inf
              p
            
            ⁢
            
              
                ∫
                0
                I
              
              ⁢
              
                
                  {
                  
                    p
                    -
                    
                      
                        s
                        ⁡
                        
                          (
                          
                            p
                            ,
                            i
                          
                          )
                        
                      
                      ⁢
                      
                        (
                        
                          
                            
                              J
                              
                                n
                                +
                                1
                              
                            
                            ⁡
                            
                              (
                              b
                              )
                            
                          
                          -
                          
                            
                              J
                              
                                n
                                +
                                1
                              
                            
                            ⁡
                            
                              (
                              
                                b
                                -
                                1
                              
                              )
                            
                          
                        
                        ]
                      
                    
                    +
                    
                      [
                      
                        
                          B
                          ⁡
                          
                            (
                            b
                            )
                          
                        
                        +
                        
                          
                            J
                            
                              n
                              +
                              1
                            
                          
                          ⁡
                          
                            (
                            b
                            )
                          
                        
                      
                      ]
                    
                  
                  }
                
                ⁢
                
                  f
                  ⁡
                  
                    (
                    i
                    )
                  
                
                ⁢
                
                  
                
                ⁢
                
                  d
                  i
                
              
            
          
        
        ,
      
    
    
      
        (
        2
        )
      
    
  




    
    
        for every 1≦n≦N, 0≦b≦K. We naturally expect that Jn+1(b)−Jn=1=(b−1)≧0 for every backlog level b and time n, since starting with a higher backlog should result at a higher cost. The terminal cost is JN+1(b)=T(b). Obviously, Jn(0)=0 for every n. Solving this family of recursive equations, we obtain the optimal power control {p*1, p*2, . . . p*n, . . . p*N}, which results in the minimum cost J1(K)—that is, the minimum overall cost.
        Dynamic programming recursions can rarely be solved analytically. Fortunately, in this case (due to the special structure of the problem), we can obtain (semi)analytical solutions which provide significant insight into the power control problem. Of particular value is the case of i.i.d. interference which is uniformly distributed in [0,I]—this captures well the essence of the problem and leads to ‘clean’ solutions.
        To specify s(p,i), the probability of successful transmission, we note that it is typically a function of
    
    






  p
  i




—the SIR (signal-to-interference ratio). A natural functional form, arising in some standard radio technologies, is simply:





  
    
      
        
          s
          ⁡
          
            (
            
              p
              ,
              i
            
            )
          
        
        =
        
          
            p
            
              
                α
                ⁢
                
                  
                
                ⁢
                p
              
              -
              
                β
                ⁢
                
                  
                
                ⁢
                i
              
            
          
          =
          
            
              2
              i
            
            
              
                α
                i
                2
              
              +
              β
            
          
        
      
    
    
      
        (
        3
        )
      
    
  




    
    
        with α≧1 and β>0 (which guarantee that s(p,i)≦1). Using this function below, the analysis is generalized to other forms in section II-D. For simplicity p is unconstrained for the moment and the power-constrained case is addressed later in section II-C. The dynamic programming recursion (2) now becomes
    
    






  
    
      
        
          
            
              J
              n
            
            ⁡
            
              (
              b
              )
            
          
          =
          
            
              inf
              p
            
            ⁢
            
              
                ∫
                0
                I
              
              ⁢
              
                
                  {
                  
                    p
                    -
                    
                      
                        p
                        
                          
                            α
                            ⁢
                            
                              
                            
                            ⁢
                            p
                          
                          +
                          
                            β
                            ⁢
                            
                              
                            
                            ⁢
                            i
                          
                        
                      
                      ⁢
                      
                        
                          X
                          n
                        
                        ⁡
                        
                          (
                          b
                          )
                        
                      
                    
                    +
                    
                      
                        Y
                        n
                      
                      ⁡
                      
                        (
                        b
                        )
                      
                    
                  
                  }
                
                ⁢
                
                  f
                  ⁡
                  
                    (
                    i
                    )
                  
                
                ⁢
                
                  
                
                ⁢
                
                  d
                  i
                
              
            
          
        
        ,
      
    
    
      
        (
        4
        )
      
    
  




    
    
        with

Xn(b)=Jn+1(b)−Jn+1(b−1)

Yn(b)=B(b)+Jn+1(b).  (5)

        Note that Yn(b)−Xn(b)=B(b)+Jn+1(b−1)≧0 for all n's and b's. We can solve the recursions using the following lemma.
    
    


Lemma 1:




  
    
      
        
          
            p
            *
          
          ⁡
          
            (
            i
            )
          
        
        =
        
          {
          
            
              
                
                  
                    
                      1
                      α
                    
                    ⁢
                    
                      (
                      
                        
                          
                            β
                            ⁢
                            
                              
                            
                            ⁢
                            X
                            ⁢
                            
                              
                            
                            ⁢
                            i
                          
                        
                        -
                        
                          β
                          ⁢
                          
                            
                          
                          ⁢
                          i
                        
                      
                      )
                    
                  
                  ,
                
              
              
                
                  i
                  <
                  
                    X
                    β
                  
                
              
            
            
              
                
                  0
                  ,
                
              
              
                
                  i
                  ⁢
                  
                    >
                    _
                  
                  ⁢
                  
                    
                      X
                      β
                    
                    .
                  
                
              
            
          
        
      
    
    
      
        (
        6
        )
      
    
  




    
    
        minimizes the functional
    
    






  
    
      
        
          
            
              F
              XY
            
            ⁡
            
              (
              i
              )
            
          
          =
          
            
              inf
              p
            
            ⁢
            
              {
              
                p
                -
                
                  
                    p
                    
                      
                        α
                        ⁢
                        
                          
                        
                        ⁢
                        p
                      
                      +
                      
                        β
                        ⁢
                        
                          
                        
                        ⁢
                        i
                      
                    
                  
                  ⁢
                  X
                
                +
                Y
              
              }
            
          
        
        ,
      
    
    
      
        (
        7
        )
      
    
  




    
    
        which attains the minimal value
    
    






  
    
      
        
          
            F
            XY
          
          ⁡
          
            (
            i
            )
          
        
        =
        
          {
          
            
              
                
                  
                    
                      
                        1
                        α
                      
                      ⁢
                      
                        (
                        
                          
                            2
                            ⁢
                            
                              
                                β
                                ⁢
                                
                                  
                                
                                ⁢
                                Xi
                              
                            
                          
                          -
                          
                            β
                            ⁢
                            
                              
                            
                            ⁢
                            i
                          
                          -
                          X
                        
                        )
                      
                    
                    +
                    Y
                  
                  ,
                
              
              
                
                  i
                  <
                  
                    X
                    β
                  
                
              
            
            
              
                
                  Y
                  ,
                
              
              
                
                  
                    i
                    ⁢
                    
                      >
                      _
                    
                    ⁢
                    
                      X
                      β
                    
                  
                  ,
                
              
            
          
        
      
    
    
      
        (
        8
        )
      
    
  




    
    
        and is FXY(i)≧0 for every iε[0,I]. Moreover, for an arbitrary distribution f(i)≧0 on [0,I], the power function (6) minimizes also the functional
    
    






  
    
      
        
          
            Φ
            ⁢
            
              {
              
                X
                <
                Y
              
              }
            
          
          =
          
            
              inf
              p
            
            ⁢
            
              
                ∫
                0
                I
              
              ⁢
              
                
                  {
                  
                    p
                    -
                    
                      
                        p
                        
                          
                            α
                            ⁢
                            
                              
                            
                            ⁢
                            p
                          
                          +
                          
                            β
                            ⁢
                            
                              
                            
                            ⁢
                            i
                          
                        
                      
                      ⁢
                      X
                    
                    +
                    Y
                  
                  }
                
                ⁢
                
                  
                
                ⁢
                
                  f
                  ⁡
                  
                    (
                    i
                    )
                  
                
                ⁢
                
                  d
                  i
                
              
            
          
        
        ,
      
    
    
      
        (
        9
        )
      
    
  




    
    
        which attains the value

Φ{X,Y}=∫0IFXY(i)f(i)di  (10)

        In particular, if i is uniformly distributed on [0,I] (hence, f(i)=) the minimum value of the functional (9) is
    
    






  
    
      
        
          
            Φ
            a
          
          ⁢
          
            {
            
              X
              ,
              Y
            
            }
          
        
        =
        
          {
          
            
              
                
                  
                    
                      5
                      ⁢
                      
                        X
                        2
                      
                    
                    
                      6
                      ⁢
                      αβ
                      ⁢
                      
                        
                      
                      ⁢
                      I
                    
                  
                  +
                  Y
                  -
                  
                    X
                    α
                  
                
              
              
                
                  I
                  ⁢
                  
                    >
                    _
                  
                  ⁢
                  
                    X
                    β
                  
                
              
            
            
              
                
                  
                    
                      
                        
                          β
                          ⁢
                          
                            
                          
                          ⁢
                          XI
                        
                        4
                      
                      
                        3
                        ⁢
                        
                          
                        
                        ⁢
                        α
                      
                    
                    -
                    
                      
                        β
                        ⁢
                        
                          
                        
                        ⁢
                        I
                      
                      
                        2
                        ⁢
                        
                          
                        
                        ⁢
                        α
                      
                    
                    +
                    Y
                    -
                    
                      X
                      α
                    
                  
                  ,
                
              
              
                
                  I
                  <
                  
                    X
                    β
                  
                
              
            
          
        
      
    
    
      
        (
        11
        )
      
    
  




    
    
        and the average power ∫Ip*(i)f(i)di, under uniform interference f(i)= is simply
    
    






  
    
      
        
          p
          avg
          *
        
        =
        
          {
          
            
              
                
                  
                    X
                    2
                  
                  
                    6
                    ⁢
                    
                      
                    
                    ⁢
                    αβ
                    ⁢
                    
                      
                    
                    ⁢
                    I
                  
                
              
              
                
                  I
                  ⁢
                  
                    >
                    _
                  
                  ⁢
                  
                    X
                    β
                  
                
              
            
            
              
                
                  
                    
                      
                        β
                        ⁢
                        
                          
                        
                        ⁢
                        XI
                      
                      2
                    
                    
                      3
                      ⁢
                      
                        
                      
                      ⁢
                      α
                    
                  
                  -
                  
                    
                      β
                      ⁢
                      
                        
                      
                      ⁢
                      I
                    
                    
                      2
                      ⁢
                      
                        
                      
                      ⁢
                      α
                    
                  
                
              
              
                
                  I
                  <
                  
                    
                      X
                      β
                    
                    .
                  
                
              
            
          
        
      
    
    
      
        (
        12
        )
      
    
  




    
    
        Proof: The p*(i) is obtained through standard differentiation for minimizing
    
    






  p
  -
  
    
      p
      
        
          α
          ⁢
          
            
          
          ⁢
          p
        
        +
        
          β
          ⁢
          
            
          
          ⁢
          i
        
      
    
    ⁢
    X
  
  +
  
    Y
    .
  




The rest are obtained through standard calculations. The Φ{X,Y} is minimized via point-wise minimization, due to its special form. We spare the details for the journal version of this paper.

    
    
        Example: It is interesting to observe the FIG. 1 which shows a family of optimal power functions p*(i) for various values of X. Note that, in general, p*(i) has an increasing phase (aggressive), followed by a decreasing one (soft backoff), and then by a zero power one (hard backoff). We will see that is a ubiquitous behavior with important practical design consequences. The average power for uniform interference is shown in FIG. 2.
        Using Lemma 1, we can now solve the dynamic programming recursion (4) to obtain the optimal power control in various time slots {p*1(i,b), p*2(i,b), . . . p*n(i,b), . . . p*N(i,b)} by
    
    






  
    
      
        
          
            p
            n
            *
          
          ⁡
          
            (
            
              i
              ,
              b
            
            )
          
        
        =
        
          {
          
            
              
                
                  
                    1
                    α
                  
                  ⁢
                  
                    (
                    
                      
                        
                          β
                          ⁢
                          
                            
                          
                          ⁢
                          
                            
                              X
                              n
                            
                            ⁡
                            
                              (
                              b
                              )
                            
                          
                          ⁢
                          i
                        
                      
                      -
                      
                        β
                        ⁢
                        
                          
                        
                        ⁢
                        i
                      
                    
                    )
                  
                
              
              
                
                  i
                  <
                  
                    
                      
                        X
                        n
                      
                      ⁡
                      
                        (
                        b
                        )
                      
                    
                    β
                  
                
              
            
            
              
                0
              
              
                
                  i
                  ⁢
                  
                    >
                    _
                  
                  ⁢
                  
                    
                      
                        X
                        n
                      
                      ⁡
                      
                        (
                        b
                        )
                      
                    
                    β
                  
                
              
            
          
        
      
    
    
      
        (
        13
        )
      
    
  




    
    
        where the {Xn(b)}'s are calculated recursively (backwards from N to 1) as follows:

Xn(b)=Φ{Xn+1(b),Yn+1(b)}−Φ{Xn+1(b−1),Yn+1(b−1)}  (14)

Yn(b)=B(b)+Φ{Xn+1(b),Yn+1(b)}  (15)

        for nε{N, N−1, N−2, . . . 3, 2, 1}, starting with XN(b)=T(b)−T(b−1) and YN(b)=B(b)+T(b). This is easy to see from (5) and (10). For the special case of uniform interference, we simply use Φu given by the analytic formula (11).
        Remark: Note that in p*(i,b) of (13) the backlog b enters through the Xn(b) alone. Naturally, Xn(b) is an increasing function of b, generating a family of power curves analogous to that of FIG. 1. We return to this point later.
        Remark: In practice, we can take the backlog cost to be linear B(b)=b and the terminal cost to be quadratic or of higher power T(b)=bγ. The higher the γ the more severe the terminal cost is going to be, so the system should spend more power to increase the probability that very few packets will remain in the queue at the end of the process at time N.

B. Incorporating Packet Arrivals and Buffer Overflows—Dynamic Formulation

    
    


The previous formulation of the power control problem does not include the possibility of packet arrival in each time slot. However, this can be easily incorporated into the model as follows. Assume that at the beginning of each time slot a packet may arrive with probability λε(0,1) or no packet arrives with probability 1−λ. Arriving packets join the queue at its tail. Each arrival event is assumed to be statistically independent from any other random events in the system (transmissions, interference, other arrivals). The queue is assumed to have total capacity Q. When a packet finds the buffer full it is blocked/rejected and a loss cost L is incurred. Otherwise, the system is identical as before (in terms of costs) and is run for N steps also.
Let J′n(b) be the expected cost-to-go in this case. To structure the dynamic programming equations below we need to order the events as follows. At the very beginning of each time slot the backlog state b is registered, which includes the packet which may have just arrived (packets can arrive only at the beginning of each slot). A packet which is successfully transmitted in a slot is removed from the queue at the end of the slot, so its removal is registered in the backlog state at the very beginning of the next slot. By considering the possible state transitions of the system, it is easy to see that:




  
    
      
        
          
            
              
                
                  
                    J
                    n
                    ′
                  
                  ⁡
                  
                    (
                    Q
                    )
                  
                
                =
                
                  
                    
                      inf
                      p
                    
                    ⁢
                    
                      
                        ∫
                        0
                        I
                      
                      ⁢
                      
                        {
                        
                          p
                          +
                          
                            
                              λ
                              [
                              
                                
                                  B
                                  ⁡
                                  
                                    (
                                    Q
                                    )
                                  
                                
                                +
                                L
                                +
                                
                                  
                                    (
                                    
                                      1
                                      -
                                      
                                        s
                                        ⁡
                                        
                                          (
                                          
                                            p
                                            ,
                                            i
                                          
                                          )
                                        
                                      
                                    
                                    )
                                  
                                  ⁢
                                  
                                    
                                      J
                                      
                                        n
                                        +
                                        1
                                      
                                      ′
                                    
                                    ⁡
                                    
                                      (
                                      Q
                                      )
                                    
                                  
                                
                                +
                                
                                  a
                                  ⁡
                                  
                                    (
                                    
                                      p
                                      ,
                                      i
                                    
                                    )
                                  
                                
                              
                              )
                            
                            ⁢
                            
                              
                            
                            ⁢
                            
                              
                                J
                                
                                  n
                                  +
                                  1
                                
                                ′
                              
                              (
                              
                                
                              
                              ⁢
                              
                                Q
                                -
                                1
                              
                              )
                            
                          
                        
                        ]
                      
                    
                  
                  +
                  
                    
                      
                        (
                        
                          1
                          -
                          λ
                        
                        )
                      
                      [
                      
                        
                          B
                          ⁡
                          
                            (
                            Q
                            )
                          
                        
                        +
                        
                          
                            (
                            
                              1
                              -
                              
                                s
                                ⁡
                                
                                  (
                                  
                                    p
                                    ,
                                    i
                                  
                                  )
                                
                              
                            
                            )
                          
                          ⁢
                          
                            
                              J
                              
                                n
                                +
                                1
                              
                              ′
                            
                            ⁡
                            
                              (
                              Q
                              )
                            
                          
                        
                        ⁢
                        
                          
                        
                        +
                        
                          s
                          ⁡
                          
                            (
                            
                              p
                              ,
                              i
                            
                            )
                          
                        
                      
                      )
                    
                    ⁢
                    
                      
                    
                    ⁢
                    
                      
                        J
                        
                          n
                          +
                          1
                        
                        ′
                      
                      (
                      
                        
                      
                      ⁢
                      
                        Q
                        -
                        
                          
                        
                        ⁢
                        1
                      
                      )
                    
                  
                
              
              ]
            
            }
          
          ⁢
          
            f
            ⁡
            
              (
              i
              )
            
          
          ⁢
          
            d
            i
          
        
        ⁢
        
          
        
      
    
    
      
        (
        16
        )
      
    
  
  
    
      
        
          
            J
            b
            ′
          
          ⁡
          
            (
            b
            )
          
        
        =
        
          
            inf
            p
          
          ⁢
          
            
              ∫
              0
              I
            
            ⁢
            
              
                {
                
                  p
                  +
                  
                    λ
                    ⁡
                    
                      [
                      
                        
                          B
                          ⁡
                          
                            (
                            
                              b
                              +
                              1
                            
                            )
                          
                        
                        +
                        
                          
                            (
                            
                              1
                              -
                              
                                a
                                ⁡
                                
                                  (
                                  
                                    p
                                    ,
                                    i
                                  
                                  )
                                
                              
                            
                            )
                          
                          ⁢
                          
                            
                              J
                              
                                n
                                +
                                1
                              
                              ′
                            
                            ⁡
                            
                              (
                              
                                b
                                +
                                1
                              
                              )
                            
                          
                        
                        +
                        
                          
                            a
                            ⁡
                            
                              (
                              
                                p
                                ,
                                i
                              
                              )
                            
                          
                          ⁢
                          
                            
                              J
                              
                                n
                                +
                                1
                              
                              ′
                            
                            ⁡
                            
                              (
                              b
                              )
                            
                          
                        
                      
                      ]
                    
                  
                  ⁢
                  
                    
                  
                  +
                  
                    
                      (
                      
                        1
                        -
                        λ
                      
                      )
                    
                    ⁡
                    
                      [
                      
                        
                          B
                          ⁡
                          
                            (
                            b
                            )
                          
                        
                        +
                        
                          
                            (
                            
                              1
                              -
                              
                                s
                                ⁡
                                
                                  (
                                  
                                    p
                                    ,
                                    i
                                  
                                  )
                                
                              
                            
                            )
                          
                          ⁢
                          
                            
                              J
                              
                                n
                                +
                                1
                              
                              ′
                            
                            ⁡
                            
                              (
                              b
                              )
                            
                          
                        
                        +
                        
                          
                            s
                            ⁡
                            
                              (
                              
                                p
                                ,
                                i
                              
                              )
                            
                          
                          ⁢
                          
                            
                              J
                              
                                n
                                +
                                1
                              
                              ′
                            
                            ⁡
                            
                              (
                              
                                b
                                -
                                1
                              
                              )
                            
                          
                        
                      
                      ]
                    
                  
                
                }
              
              ⁢
              
                f
                ⁡
                
                  (
                  i
                  )
                
              
              ⁢
              
                d
                i
              
            
          
        
      
    
    
      
        (
        17
        )
      
    
  
  
    
      
        
          
            J
            n
            ′
          
          ⁡
          
            (
            0
            )
          
        
        =
        
          
            inf
            p
          
          ⁢
          
            
              ∫
              0
              I
            
            ⁢
            
              {
              
                p
                +
                
                  λ
                  ⁡
                  
                    [
                    
                      
                        B
                        ⁡
                        
                          (
                          1
                          )
                        
                      
                      +
                      
                        
                          (
                          
                            1
                            -
                            
                              s
                              ⁡
                              
                                (
                                
                                  p
                                  ,
                                  i
                                
                                )
                              
                            
                          
                          )
                        
                        ⁢
                        
                          
                            J
                            
                              n
                              +
                              1
                            
                            ′
                          
                          ⁡
                          
                            (
                            1
                            )
                          
                        
                      
                      +
                      
                        
                          s
                          ⁡
                          
                            (
                            
                              p
                              ,
                              i
                            
                            )
                          
                        
                        ⁢
                        
                          
                            J
                            
                              n
                              +
                              1
                            
                            ′
                          
                          ⁡
                          
                            (
                            0
                            )
                          
                        
                      
                    
                    ]
                  
                
                ⁢
                
                  
                
                +
              
            
          
        
      
    
    
      
        (
        18
        )
      
    
  
  
    
      
        
          
            
          
          ⁢
          
            
              (
              
                1
                -
                λ
              
              )
            
            [
            
              
            
            ⁢
            
              
                B
                ⁡
                
                  (
                  0
                  )
                
              
              +
              
                
                  J
                  
                    n
                    +
                    1
                  
                  ′
                
                ⁡
                
                  (
                  0
                  )
                
              
            
            ]
          
          }
        
        ⁢
        
          f
          ⁡
          
            (
            i
            )
          
        
        ⁢
        
          d
          i
        
      
    
    
      
        (
        19
        )
      
    
  




where 0<b<Q. Rearranging the terms we get





  
    
      
        
          
            
              J
              n
              ′
            
            ⁡
            
              (
              Q
              )
            
          
          =
          
            
              inf
              p
            
            ⁢
            
              
                ∫
                0
                I
              
              ⁢
              
                
                  {
                  
                    p
                    -
                    
                      
                        s
                        ⁡
                        
                          (
                          
                            p
                            ,
                            i
                          
                          )
                        
                      
                      ⁢
                      
                        
                          X
                          n
                          ′
                        
                        ⁡
                        
                          (
                          Q
                          )
                        
                      
                    
                    +
                    
                      
                        Y
                        n
                        ′
                      
                      ⁢
                      
                        
                      
                      (
                      Q
                      )
                    
                  
                  )
                
                ⁢
                
                  f
                  ⁡
                  
                    (
                    i
                    )
                  
                
                ⁢
                
                  d
                  i
                
              
            
          
        
        ,
      
    
    
      
        (
        20
        )
      
    
  




where

X′n(Q)=J′n+1(Q)−J′n+1(Q−1)  (21)

Y′n(Q)=B(Q)+λL+J′n+1(Q),  (22)

and for 0<b<Q





  
    
      
        
          
            
              J
              n
              ′
            
            ⁡
            
              (
              b
              )
            
          
          =
          
            
              inf
              p
            
            ⁢
            
              
                ∫
                0
                I
              
              ⁢
              
                
                  {
                  
                    
                      p
                      -
                    
                    ∋
                    
                      
                        
                          (
                          
                            p
                            ,
                            i
                          
                          )
                        
                        ⁢
                        
                          
                            X
                            n
                            ′
                          
                          ⁡
                          
                            (
                            b
                            )
                          
                        
                      
                      +
                      
                        
                          Y
                          n
                          ′
                        
                        ⁡
                        
                          (
                          b
                          )
                        
                      
                    
                  
                  }
                
                ⁢
                
                  f
                  ⁡
                  
                    (
                    i
                    )
                  
                
                ⁢
                
                  
                
                ⁢
                
                  d
                  i
                
              
            
          
        
        ,
      
    
    
      
        (
        23
        )
      
    
  




where

Xn(b)=λ[J′n+1(b+1)−J′n+1(b)]+(1−λ)[J′n+1(b)−J′n+1(b−1)]  (24)

Yn(b)=λ[B(b+1)+J′n+1(b+1)]+(1−λ)[B(b)+J′n+1(b)]  (25)

and





  
    
      
        
          
            
              J
              n
              ′
            
            ⁡
            
              (
              0
              )
            
          
          =
          
            
              inf
              p
            
            ⁢
            
              
                ∫
                0
                I
              
              ⁢
              
                
                  {
                  
                    p
                    -
                    
                      
                        s
                        ⁡
                        
                          (
                          
                            p
                            ,
                            i
                          
                          )
                        
                      
                      ⁢
                      
                        
                          X
                          n
                          ′
                        
                        ⁡
                        
                          (
                          0
                          )
                        
                      
                    
                    +
                    
                      
                        Y
                        n
                        ′
                      
                      ⁡
                      
                        (
                        0
                        )
                      
                    
                  
                  }
                
                ⁢
                
                  f
                  ⁡
                  
                    (
                    i
                    )
                  
                
                ⁢
                
                  
                
                ⁢
                
                  d
                  i
                
              
            
          
        
        ,
      
    
    
      
        (
        26
        )
      
    
  




where

X′n(0)=λ[J′n+1(1)−J′n+1(0)]  (27)

Y′n(0)=λB(1)+(1−λ)[B(0)+J′n+1(0)]  (28)

Observe that when we substitute




  
    s
    ⁡
    
      (
      
        p
        ,
        i
      
      )
    
  
  =
  
    p
    
      
        α
        ⁢
        
          
        
        ⁢
        p
      
      +
      βi
    
  




the previous formulas take the form of (9) and satisfy the assumptions of Lemma 1, so the optimal power control sequence {p*1(i,b), p*2(i,b), . . . p*n(i,b), . . . p*N(i,b)} is given in this case by:





  
    
      
        
          
            p
            n
            *
          
          ⁡
          
            (
            
              i
              ,
              b
            
            )
          
        
        =
        
          {
          
            
              
                
                  
                    1
                    α
                  
                  ⁢
                  
                    (
                    
                      
                        
                          β
                          ⁢
                          
                            
                          
                          ⁢
                          
                            
                              X
                              n
                              ′
                            
                            ⁡
                            
                              (
                              b
                              )
                            
                          
                          ⁢
                          i
                        
                      
                      -
                      
                        β
                        ⁢
                        
                          
                        
                        ⁢
                        i
                      
                    
                    )
                  
                
              
              
                
                  i
                  <
                  
                    
                      
                        X
                        n
                        ′
                      
                      ⁡
                      
                        (
                        b
                        )
                      
                    
                    β
                  
                
              
            
            
              
                0
              
              
                
                  i
                  ≥
                  
                    
                      
                        X
                        n
                        ′
                      
                      ⁡
                      
                        (
                        b
                        )
                      
                    
                    β
                  
                
              
            
          
        
      
    
    
      
        (
        29
        )
      
    
  




where the X′n(b)'s are calculated recursively (backwards—from N to 1) as follows:

X′n(Q)=Φ{X′n+1(Q),Y′n+1(Q)}−Φ{X′n+1(Q−1),Y′n+1(Q−1)}  (30)

Y′n(Q)=B(Q)+λL+Φ{X′n+1(Q),Y′n+1(Q)}  (31)





  
    
      
        
          
            X
            n
            ′
          
          ⁡
          
            (
            b
            )
          
        
        =
        
          
            λΦ
            ⁢
            
              
            
            ⁢
            
              {
              
                
                  
                    X
                    
                      n
                      +
                      1
                    
                    ′
                  
                  ⁡
                  
                    (
                    
                      b
                      +
                      1
                    
                    )
                  
                
                ,
                
                  
                    Y
                    
                      n
                      +
                      1
                    
                    ′
                  
                  ⁡
                  
                    (
                    
                      b
                      +
                      1
                    
                    )
                  
                
                ,
                
                  
                    Y
                    
                      n
                      +
                      1
                    
                    ′
                  
                  ⁡
                  
                    (
                    
                      b
                      -
                      1
                    
                    )
                  
                
              
              }
            
          
          -
          
            λΦ
            ⁢
            
              {
              
                
                  
                    X
                    
                      n
                      +
                      1
                    
                    ′
                  
                  ⁡
                  
                    (
                    b
                    )
                  
                
                ,
                
                  
                    Y
                    
                      n
                      +
                      1
                    
                    ′
                  
                  ⁡
                  
                    (
                    b
                    )
                  
                
              
              }
            
          
          +
          
            
              (
              
                1
                -
                λ
              
              )
            
            ⁢
            Φ
            ⁢
            
              {
              
                
                  
                    X
                    
                      n
                      +
                      1
                    
                    ′
                  
                  ⁡
                  
                    (
                    b
                    )
                  
                
                ,
                
                  
                    Y
                    
                      n
                      +
                      1
                    
                    ′
                  
                  ⁡
                  
                    (
                    b
                    )
                  
                
              
              }
            
          
          -
          
            
              (
              
                1
                -
                λ
              
              )
            
            ⁢
            Φ
            ⁢
            
              {
              
                
                  
                    X
                    
                      n
                      +
                      1
                    
                    ′
                  
                  ⁡
                  
                    (
                    
                      b
                      -
                      1
                    
                    )
                  
                
                ,
                
                  
                    Y
                    
                      n
                      +
                      1
                    
                    ′
                  
                  ⁡
                  
                    (
                    
                      b
                      -
                      1
                    
                    )
                  
                
              
              }
            
          
        
      
    
    
      
        (
        32
        )
      
    
  








  
    
      
        
          
            
              
                Y
                n
                ′
              
              ⁡
              
                (
                b
                )
              
            
            =
            
              
                λ
                ⁢
                
                  
                
                ⁢
                
                  B
                  ⁡
                  
                    (
                    
                      b
                      +
                      1
                    
                    )
                  
                
              
              +
              
                λΦ
                ⁢
                
                  {
                  
                    
                      
                        X
                        
                          n
                          +
                          1
                        
                        ′
                      
                      ⁡
                      
                        (
                        
                          b
                          +
                          1
                        
                        )
                      
                    
                    ,
                    
                      
                        Y
                        
                          n
                          +
                          1
                        
                        ′
                      
                      ⁡
                      
                        (
                        
                          b
                          +
                          1
                        
                        )
                      
                    
                  
                  }
                
              
            
          
          )
        
        +
        
          
            (
            
              1
              -
              λ
            
            )
          
          ⁢
          
            B
            ⁡
            
              (
              b
              )
            
          
        
        +
        
          
            (
            
              1
              -
              λ
            
            )
          
          ⁢
          Φ
          ⁢
          
            {
            
              
                
                  X
                  
                    n
                    +
                    1
                  
                  ′
                
                ⁡
                
                  (
                  b
                  )
                
              
              ,
              
                
                  Y
                  
                    
                      n
                      +
                      1
                    
                    ⁢
                    
                      
                    
                  
                  ′
                
                ⁡
                
                  (
                  b
                  )
                
              
            
            }
          
        
      
    
    
      
        (
        33
        )
      
    
  




X′n(0)=λ[Φ{X′n+1(1),Y′n+1(1)}−Φ{X′n+1(0),Y′n+1(0)}]  (34)

Y′n(0)=λB(1)+(1−λ)[B(0)+Φ{X′n+1(0),Y′n+1(0)}]  (35)

for nε{N, N−1, N−2, . . . 3, 2, 1}, starting with XN(b)=T(b)−T(b−1) and YN(b)=B(b)+T(b).

Remarks: The functional form of the optimal power control (29) in this case is identical to the (13) and (6) before. Only the X-parameter changes, which reflect the backlog-sensitivity of the power control and incorporates the additional aspects (arrivals with probability λ and loss cost L).

C. Finite Power Ceiling

In the discussions above, we have always assumed that the power is unconstrained, that is, pε[0,∞} in order to simplify the presentation. In practice, however, there is a maximum power that the transmitter can transmit at, which we call power ceiling and denote by Pmax<∞. Fortunately, very little changes in this case and the results carry over naturally. The minimization (9) in Lemma 1 is now over pε[0,Pmax] and the optimal power function (6) changes slightly to




  
    
      
        
          
            p
            *
          
          ⁡
          
            (
            i
            )
          
        
        =
        
          {
          
            
              
                
                  
                    min
                    ⁢
                    
                      {
                      
                        
                          
                            1
                            α
                          
                          ⁢
                          
                            (
                            
                              
                                
                                  β
                                  ⁢
                                  
                                    
                                  
                                  ⁢
                                  Xi
                                
                              
                              -
                              
                                β
                                ⁢
                                
                                  
                                
                                ⁢
                                i
                              
                            
                            )
                          
                        
                        ,
                        
                          P
                          max
                        
                      
                      }
                    
                  
                  ,
                
              
              
                
                  i
                  <
                  
                    X
                    β
                  
                
              
            
            
              
                
                  0
                  ,
                
              
              
                
                  
                    i
                    ≥
                    
                      X
                      β
                    
                  
                  ,
                
              
            
          
        
      
    
    
      
        (
        36
        )
      
    
  




that is, it is clipped at Pmax. This affects Φ(X,Y), which must be recomputed now. The Xn, Yn and X′n, Y′n, are now computed in exactly the same way as before, but using the new formula for Φ.

D. General Packet Success Probability

In Lemma 1, we assumed that the probability of success for packet transmission is of the form




  
    
      s
      ⁡
      
        (
        
          p
          ,
          i
        
        )
      
    
    =
    
      
        p
        
          
            α
            ⁢
            
              
            
            ⁢
            p
          
          +
          βi
        
      
      =
      
        
          (
          
            p
            /
            i
          
          )
        
        
          
            α
            ⁡
            
              (
              
                p
                /
                i
              
              )
            
          
          +
          β
        
      
    
  
  ,




the





  p
  i




being the SIR. Lemma 1, and all its results, can be easily generalized to s(p,i)=g(p/i), where g(x)ε[0,1] is an increasing differentiable function, as is naturally the case in communication systems.

Then it is easy to see that the basic functional inf




  
    
      
    
    p
  
  ⁢
  
    
      ∫
      0
      I
    
    ⁢
    
      
        {
        
          p
          -
          
            
              g
              ⁡
              
                (
                
                  p
                  i
                
                )
              
            
            ⁢
            X
          
          +
          Y
        
        }
      
      ⁢
      
        f
        ⁡
        
          (
          i
          )
        
      
      ⁢
      
        
      
      ⁢
      
        d
        i
      
    
  




is minimized for p*(i) which satisfies the equation





  
    
      
        
          
            d
            g
          
          
            d
            x
          
        
        ⁢
        
          
          
            
              p
              *
            
            =
            
              
                i
                X
              
              .
            
          
        
      
    
    
      
        (
        37
        )
      
    
  




Indeed, this minimizes the expression





  p
  -
  
    
      g
      ⁡
      
        (
        
          P
          i
        
        )
      
    
    ⁢
    X
  
  +
  Y




for every fixed i, X, Y. The specific distribution f(i) does not play a role here. Of particular interest is the function





  
    
      
        
          s
          ⁡
          
            (
            
              p
              ,
              i
            
            )
          
        
        =
        
          1
          -
          
            e
            
              δ
              ⁡
              
                (
                
                  p
                  i
                
                )
              
            
          
        
      
    
    
      
        (
        38
        )
      
    
  




which appears in certain communication technologies [6]. In this case, the optimal power control function p*(i), minimizing the function





  
    
      
        
          
            Ψ
            ⁢
            
              {
              
                X
                ,
                Y
              
              }
            
          
          =
          
            
              inf
              
                p
                ∈
                
                  [
                  
                    0
                    ,
                    
                      P
                      max
                    
                  
                  ]
                
              
            
            ⁢
            
              
                ∫
                0
                I
              
              ⁢
              
                
                  {
                  
                    p
                    -
                    
                      
                        (
                        
                          1
                          -
                          
                            e
                            
                              δ
                              ⁡
                              
                                (
                                
                                  p
                                  *
                                
                                )
                              
                            
                          
                        
                        )
                      
                      ⁢
                      X
                    
                    +
                    Y
                  
                  }
                
                ⁢
                
                  f
                  ⁡
                  
                    (
                    i
                    )
                  
                
                ⁢
                
                  
                
                ⁢
                
                  d
                  i
                
              
            
          
        
        ,
        
          

        
        ⁢
        
          
            (
            
              X
              ≥
              Y
              ≥
              0
            
            )
          
          ⁢
          
            
          
          ⁢
          is
          ⁢
          
            
          
          ⁢
          simply
        
      
    
    
      
        (
        39
        )
      
    
  
  
    
      
        
          
            p
            *
          
          ⁡
          
            (
            i
            )
          
        
        =
        
          {
          
            
              
                
                  
                    min
                    ⁢
                    
                      {
                      
                        
                          
                            -
                            
                              i
                              δ
                            
                          
                          ⁢
                          log
                          ⁢
                          
                            i
                            δX
                          
                        
                        ,
                        
                          P
                          max
                        
                      
                      }
                    
                  
                  ,
                
              
              
                
                  i
                  <
                  
                    δ
                    ⁢
                    
                      
                    
                    ⁢
                    X
                  
                
              
            
            
              
                
                  0
                  ,
                
              
              
                
                  
                    i
                    ≥
                    δX
                  
                  ,
                
              
            
          
        
      
    
    
      
        (
        40
        )
      
    
  




irrespectively of the distribution density f(i). Of course, the latter does affect the actual minimal value of ψ(X,Y) which is ultimately used to compute the dependence of X on the backlog b. Example: FIG. 3 shows the optimal power control curves





  
    
      p
      *
    
    ⁡
    
      (
      i
      )
    
  
  =
  
    
      -
      i
    
    ⁢
    
      
    
    ⁢
    
      log
      ⁡
      
        (
        
          i
          X
        
        )
      
    
  




for various values of X. Note that the ‘shape’ and behavior of the power curves in FIG. 3 are very similar to those in FIG. 1. This structural property is used later as discussed below.

E. Markovian Interference

Up to now, we have assumed that the interference levels in in different time slots are i.i.d. random variables, distributed with some general density f(i). However, the methodology and results presented above, extend naturally to the case of Markovian interference. Indeed, let there be a discrete finite set of interference states I and let in be a time-homogeneous Markov chain with transition probabilities P[in+1=j|in=i]=qij from state iεI to jεI. We assume that the Markov chain is irreducible and has a stationary distribution ν(I) iεI. We assume that arrival and transmission events are independent of the interference Markov chain. In this case, we can again analyze the system using the same dynamic programming methodology. Indeed, consider the dynamic formulation of section II-B and let Vn(b,i), be the expected cost-to-go from state (b,i) at time n, that is, the minimal cost to be incurred under optimal power control, given that the system starts at time n from backlog state b and interference state i. The dynamic programming equation for every 0<b<Q and iεI then becomes:




  
    
      
        
          
            V
            n
          
          ⁡
          
            (
            
              b
              ,
              i
            
            )
          
        
        =
        
          min
          ⁢
          
            {
            
              p
              +
              
                λ
                [
                
                  
                    B
                    ⁡
                    
                      (
                      
                        b
                        +
                        1
                      
                      )
                    
                  
                  +
                  
                    
                      (
                      
                        1
                        -
                        
                          s
                          ⁡
                          
                            (
                            
                              p
                              ,
                              i
                            
                            )
                          
                        
                      
                      )
                    
                    ⁢
                    
                      
                        ∑
                        
                          j
                          ∈
                          I
                        
                        
                          
                        
                      
                      ⁢
                      
                        
                      
                      ⁢
                      
                        
                          q
                          ij
                        
                        ⁢
                        
                          
                            V
                            
                              n
                              +
                              1
                            
                          
                          ⁡
                          
                            (
                            
                              
                                b
                                +
                                1
                              
                              ,
                              j
                            
                            )
                          
                        
                      
                    
                  
                  +
                  
                    
                      s
                      ⁡
                      
                        (
                        
                          p
                          ,
                          i
                        
                        )
                      
                    
                    ⁢
                    
                      
                    
                    ⁢
                    
                      
                        ∑
                        
                          j
                          ∈
                          I
                        
                        
                          
                        
                      
                      ⁢
                      
                        
                      
                      ⁢
                      
                        
                          q
                          ij
                        
                        ⁢
                        
                          
                            V
                            
                              n
                              +
                              1
                            
                          
                          ⁡
                          
                            (
                            
                              b
                              ,
                              j
                            
                            )
                          
                        
                      
                    
                  
                
                ]
              
              +
              
                
                  (
                  
                    1
                    -
                    λ
                  
                  )
                
                [
                
                  
                    B
                    ⁡
                    
                      (
                      b
                      )
                    
                  
                  +
                  
                    
                      (
                      
                        1
                        -
                        
                          s
                          ⁡
                          
                            (
                            
                              p
                              ,
                              i
                            
                            )
                          
                        
                      
                      )
                    
                    ⁢
                    
                      
                        ∑
                        
                          j
                          ∈
                          I
                        
                        
                          
                        
                      
                      ⁢
                      
                        
                      
                      ⁢
                      
                        
                          q
                          ij
                        
                        ⁢
                        
                          
                            V
                            
                              n
                              +
                              1
                            
                          
                          ⁡
                          
                            (
                            
                              b
                              ,
                              j
                            
                            )
                          
                        
                      
                    
                  
                  +
                  
                    
                      s
                      ⁡
                      
                        (
                        
                          p
                          ,
                          i
                        
                        )
                      
                    
                    ⁢
                    
                      
                        ∑
                        
                          j
                          ∈
                          I
                        
                        
                          
                        
                      
                      ⁢
                      
                        
                      
                      ⁢
                      
                        
                          q
                          ij
                        
                        ⁢
                        
                          
                            V
                            
                              n
                              +
                              1
                            
                          
                          ⁡
                          
                            (
                            
                              
                                b
                                -
                                1
                              
                              ,
                              j
                            
                            )
                          
                        
                      
                    
                  
                
                ]
              
            
            }
          
        
      
    
    
      
        (
        41
        )
      
    
  




and by rearranging the terms





  
    
      
        
          
            V
            n
          
          ⁡
          
            (
            
              b
              ,
              i
            
            )
          
        
        =
        
          
            min
            p
          
          ⁢
          
            
              {
              
                p
                -
                
                  
                    θ
                    ⁡
                    
                      (
                      
                        p
                        ,
                        i
                      
                      )
                    
                  
                  ⁢
                  
                    
                      X
                      n
                    
                    ⁡
                    
                      (
                      
                        b
                        ,
                        i
                      
                      )
                    
                  
                
                +
                
                  
                    Y
                    n
                  
                  ⁡
                  
                    (
                    
                      b
                      ,
                      i
                    
                    )
                  
                
              
              }
            
            ⁢
            
              
            
            ⁢
            with
          
        
      
    
    
      
        (
        42
        )
      
    
  
  
    
      
        
          
            X
            n
          
          ⁡
          
            (
            
              b
              ,
              i
            
            )
          
        
        =
        
          
            ∑
            
              j
              ∈
              I
            
            
              
            
          
          ⁢
          
            
          
          ⁢
          
            
              q
              ij
            
            ⁢
            
              {
              
                
                  λ
                  ⁡
                  
                    [
                    
                      
                        
                          V
                          
                            n
                            +
                            1
                          
                        
                        ⁡
                        
                          (
                          
                            
                              b
                              +
                              1
                            
                            ,
                            j
                          
                          )
                        
                      
                      -
                      
                        
                          V
                          
                            n
                            +
                            1
                          
                        
                        ⁡
                        
                          (
                          
                            b
                            ,
                            j
                          
                          )
                        
                      
                    
                    ]
                  
                
                +
                
                  
                    (
                    
                      1
                      -
                      λ
                    
                    )
                  
                  ⁡
                  
                    [
                    
                      
                        
                          V
                          
                            n
                            +
                            1
                          
                        
                        ⁡
                        
                          (
                          
                            b
                            ,
                            j
                          
                          )
                        
                      
                      -
                      
                        
                          V
                          
                            n
                            -
                            1
                          
                        
                        ⁡
                        
                          (
                          
                            
                              b
                              -
                              1
                            
                            ,
                            j
                          
                          )
                        
                      
                    
                    ]
                  
                
              
              }
            
            ⁢
            
              
            
            ⁢
            and
          
        
      
    
    
      
        (
        43
        )
      
    
  
  
    
      
        
          
            Y
            n
          
          ⁡
          
            (
            
              b
              ,
              i
            
            )
          
        
        =
        
          
            ∑
            
              j
              ∈
              I
            
            
              
            
          
          ⁢
          
            
          
          ⁢
          
            
              q
              ij
            
            ⁢
            
              
                {
                
                  
                    λ
                    ⁡
                    
                      [
                      
                        
                          B
                          ⁡
                          
                            (
                            
                              b
                              +
                              1
                            
                            )
                          
                        
                        +
                        
                          λ
                          ⁢
                          
                            
                          
                          ⁢
                          
                            
                              V
                              
                                n
                                +
                                1
                              
                            
                            ⁡
                            
                              (
                              
                                
                                  b
                                  +
                                  1
                                
                                ,
                                j
                              
                              )
                            
                          
                        
                      
                      ]
                    
                  
                  ⁢
                  
                    
                      (
                      
                        1
                        -
                        λ
                      
                      )
                    
                    ⁡
                    
                      [
                      
                        
                          B
                          ⁡
                          
                            (
                            b
                            )
                          
                        
                        +
                        
                          
                            V
                            
                              n
                              +
                              1
                            
                          
                          ⁡
                          
                            (
                            
                              b
                              ,
                              j
                            
                            )
                          
                        
                      
                      ]
                    
                  
                
                }
              
              .
            
          
        
      
    
    
      
        (
        44
        )
      
    
  




Moreover, for the boundary cases b=0 and b=Q we need to write special equations, analogous to those in section II-B. We omit them here in the interest of space, especially since they have similar functional forms as the ones above.

For




  
    
      s
      ⁡
      
        (
        
          p
          ,
          i
        
        )
      
    
    =
    
      p
      
        
          α
          ⁢
          
            
          
          ⁢
          p
        
        +
        
          β
          ⁢
          
            
          
          ⁢
          i
        
      
    
  
  ,




equation (42) is covered by Lemma 1, an the optimal power control turns out to be again





  
    
      
        
          
        
        ⁢
        
          
            
              p
              n
              *
            
            ⁡
            
              (
              
                i
                ,
                b
              
              )
            
          
          =
          
            {
            
              
                
                  
                    
                      1
                      α
                    
                    ⁢
                    
                      (
                      
                        
                          
                            β
                            ⁢
                            
                              
                            
                            ⁢
                            
                              
                                X
                                n
                              
                              ⁡
                              
                                (
                                
                                  b
                                  ,
                                  i
                                
                                )
                              
                            
                            ⁢
                            i
                          
                        
                        -
                        
                          β
                          ⁢
                          
                            
                          
                          ⁢
                          i
                        
                      
                      )
                    
                  
                
                
                  
                    i
                    <
                    
                      
                        
                          X
                          n
                        
                        ⁡
                        
                          (
                          
                            b
                            ,
                            i
                          
                          )
                        
                      
                      β
                    
                  
                
              
              
                
                  0
                
                
                  
                    
                      i
                      ≥
                      
                        
                          
                            X
                            n
                            ′
                          
                          ⁡
                          
                            (
                            b
                            )
                          
                        
                        β
                      
                    
                    ,
                  
                
              
            
          
        
      
    
    
      
        (
        45
        )
      
    
  




where the Xn(b,i)'s are computed again using the corresponding recursive relations. For other s(p,i)'s the system is treated similarly.

F. Incorporating Packet Deadlines

Finally, another interesting formulation of the power control problem can be obtained by introducing deadlines associated with the packets. Each one has to be successfully transmitted by a deadline after its arrival; otherwise, it expires and gets dropped from the buffer, while a cost is incurred by the system. The problem is precisely formulated as follows.
Assume that each packet has a deadline of D time slots after its arrival, by which it has to be transmitted before it expires and is eliminated from the queue. When a packet expires a cost E is incurred. Again we assume that the buffer has capacity Q, as in section (II-B). The queue state of the system at time n is the Q-dimensional vector

Rn=(rn1, rn2, rn3, . . . rnk, . . . rnQ)  (46)

where





  r
  ⁢
  
    k
    n
  




is the residual lifetime of the packet at the kth position of the queue at time n. Since the queue is FIFO, we must have





  
    r
    ⁢
    
      1
      n
    
  
  <
  
    r
    ⁢
    
      2
      n
    
  
  <
  
    r
    ⁢
    
      3
      n
    
  
  <
  ...
  <
  
    r
    ⁢
    
      k
      n
    
  
  <
  ...
  <
  
    r
    ⁢
    
      
        Q
        n
      
      .
    
  




Given that the backlog of the queue at time n is bn, we assign





  
    r
    ⁢
    
      k
      n
    
  
  =
  ∞




for every kε{bn+1, . . . Q}, by convention. That is, we artificially assign infinite residual lifetime rk=∞ to buffer positions k that currently hold no packet. Note that since each packet can stay in the queue for at most D time slots, there will never be more than D packets in the queue even if the buffer has capacity Q>D. If Q≦D, however, the buffer can have up to Q packets.

The complete state of the system at time n is (Rn,in), which has Markovian dynamics. It is easy to compute the transition probabilities. For example, transitions of the type (R;i)=(r1, r2, r3, . . . rk, . . . rb, ∞, ∞, . . . ∞;i)→(R′;j)=(r1−1, r2−1, r3−1, . . . rk−1, . . . rb−1, D, ∞, ∞, . . . ∞;j), correspond to a packet arriving, none expiring (hence, r1>0), none getting successfully transmitted, and the interference switching from i to j. The probability of such transitions are λ(1−s(p,i)qij). Similarly, transition f of the type (R;i)=(r1, r2, r3, . . . rk, . . . rb, ∞, ∞, . . . ∞;i)→(R′;j)=(r2−1, r3−1, . . . rk−1, . . . rb−1, D, ∞, ∞, . . . ∞;j),
Correspond to a packet arriving, none expiring (r1>0), one being successfully transmitted, and the interference switching from i to j. The probability of such transitions are λs(p,i)qij. In the same way, it is easy to identify all possible transitions (R;i)→(R′;j) and the corresponding probabilities, which turn out to be of the general form εRR′(p,i)qij. Given that the system is in state (R;i), we can easily compute the cost C(p,R,i) incurred in the current time slot. Letting Un(R,i) be the cost-to-go, the dynamic programming recursion then becomes Vn(R,i)=minp{C(p,R)+ΣR′εRR′ΣjqijVn+1(R′;j).} It turns out that due to the nature of the cost C(p,R,i), Lemma 1 applies again and we obtain an optimal power control similar in functional form to that in (45). We omit the details, to be included in the journal version of this paper, but the method and process should be already clear.

III. Design and Evaluation of PCMA Algorithms

In the previous section, we have analyzed the case of a single power controlled link, operating in an environment of random interference which is unresponsive to its actions. Of great interest, of course, is the case of multiple interfering links operating in a common, shared radio channel. From each individual link's perspective all the others can be treated as a random interference environment. The big difference, however, is that this environment is now responsive to the link transmitter's actions. Indeed, the link increasing its power raises the interference on other links, which may in turn increase their powers in response and hence cause an increase in interference on the original link.
We aim to design power control algorithms for efficient channel sharing, that is, to maximize the aggregate effective throughput of the channel, to minimize the power used to support a certain required quality of service (QoS) for its users, maximize the channel capacity in terms of number of supported users at a fixed QoS etc. Such algorithms should be simple, distributed, autonomous (and possibly asynchronous) in order to scale well in large wireless network architectures.
Consider a radio channel and a number of communication links in it, operating in slotted time. Each link can only observe the past and present states of its queue backlog, transmitted power and collective (aggregate) interference, induced on it by all other transmitters sharing the channel. Based on this information, it needs to decide what power to transmit at in the next time slot. That is, each transmitter uses exclusively locally observed information to autonomously control its transmitted power. Let bn be the transmitter queue backlog in the nth time slot, in the interference observed during that slot at the receiver of the communication link, and pn the power transmitted in the slot. We assume that the slot is defined by the time needed to transmit a packet (or bit or any information unit). The receiver communicates interference measurements (and ACKs/NACks) to the transmitter typically on a low-rate reliable reverse channel, which is perhaps a separate control channel. Let G be the power gain from the transmitter to the receiver of the link.
We first consider a simple distributed algorithm for PCMA, which is based on the idea of attempting to transmit each packet at a constant SIR, shooting for a fixed probability of success in the process. Let γt be the target SIR the link needs to maintain and




  
    γ
    n
  
  =
  
    
      Gp
      n
    
    
      i
      n
    
  




the SIR observed during the nth time slot. The power control algorithm is simply:

Constant-SIR Algorithm: (standard benchmark)





  
    
      
        
          p
          
            n
            +
            1
          
        
        =
        
          {
          
            
              
                
                  
                    
                      
                        γ
                        t
                      
                      G
                    
                    ⁢
                    
                      i
                      n
                    
                  
                  =
                  
                    
                      
                        γ
                        t
                      
                      
                        γ
                        n
                      
                    
                    ⁢
                    
                      p
                      n
                    
                  
                
              
              
                
                  
                    b
                    n
                  
                  >
                  0
                
              
            
            
              
                0
              
              
                
                  
                    
                      b
                      n
                    
                    =
                    0
                  
                  ,
                
              
            
          
        
      
    
    
      
        (
        47
        )
      
    
  




that is, each link in the channel updates its power autonomously, according to the above scheme, in consecutive time slots.

Note that the link increases its power in the next time slot, if the SIR it observed in the current one was below the target γt and decreases it otherwise. Therefore, it always tries to achieve a constant SIR γt and a corresponding constant transmission success probability, when it has a packet to transmit. The algorithm is obviously distributed and autonomous, since it uses only local information. We call the above algorithm standard and use it as a benchmark for our performance studies below, comparing it to others introduced later.
The standard algorithm above is essentially an extension of the basic power control algorithm initially introduced by Foschini & Miljanic [1] for voice-oriented continuous traffic in wireless networks. This has been extensively studied and shown to have several optimality properties for continuous traffic. The scheme (47) extends it to data traffic, given the previous formulation of the problem. Because of its importance in the literature of power control for continuous traffic, it naturally provides the benchmark of the study of PCMA algorithms for packetized data traffic in this paper.
We introduce below a new family of algorithms, motivated by the power control problem formulation and structural analysis of section II. Indeed, we have seen that the functional form of the optimal power control is ubiquitous in several dynamic programming formulations of the previous section. This leads us to introduce the following two new classes of algorithms. For a success probability of the form (α≧1, β>0):




  
    
      
        
          s
          ⁡
          
            (
            
              p
              ,
              i
            
            )
          
        
        =
        
          
            p
            
              
                α
                ⁢
                
                  
                
                ⁢
                p
              
              +
              
                β
                ⁢
                
                  
                
                ⁢
                i
              
            
          
          =
          
            
              p
              i
            
            
              
                α
                i
                p
              
              +
              β
            
          
        
      
    
    
      
        (
        48
        )
      
    
  




the power control algorithm is:

PCMA-1 Algorithms: Each link in the channel updates its power according to the following scheme in consecutive time slots:





  
    
      
        
          p
          
            n
            +
            1
          
        
        =
        
          {
          
            
              
                
                  
                    
                      1
                      α
                    
                    ⁢
                    
                      (
                      
                        
                          
                            β
                            ⁢
                            
                              
                            
                            ⁢
                            
                              X
                              ⁡
                              
                                (
                                
                                  b
                                  n
                                
                                )
                              
                            
                            ⁢
                            
                              i
                              n
                            
                          
                        
                        -
                        
                          β
                          ⁢
                          
                            
                          
                          ⁢
                          
                            i
                            n
                          
                        
                      
                      )
                    
                  
                  ,
                
              
              
                
                  
                    i
                    n
                  
                  <
                  
                    
                      X
                      ⁡
                      
                        (
                        
                          b
                          n
                        
                        )
                      
                    
                    β
                  
                
              
            
            
              
                
                  0
                  ,
                
              
              
                
                  
                    
                      i
                      n
                    
                    ≥
                    
                      
                        X
                        ⁡
                        
                          (
                          
                            b
                            n
                          
                          )
                        
                      
                      β
                    
                  
                  ,
                
              
            
          
        
      
    
    
      
        (
        49
        )
      
    
  




where X(b) is an increasing function of the transmitter queue backlog. Particular selections generates a family of algorithms.

Note that the PCMA-1 algorithms are trying to shoot for a variable SIR target.




  
    
      
        
          
            γ
            1
            t
          
          ⁡
          
            (
            
              b
              ,
              i
            
            )
          
        
        =
        
          {
          
            
              
                
                  
                    
                      1
                      α
                    
                    ⁢
                    
                      (
                      
                        
                          
                            β
                            ⁢
                            
                              
                                X
                                ⁡
                                
                                  (
                                  b
                                  )
                                
                              
                              i
                            
                          
                        
                        -
                        β
                      
                      )
                    
                  
                  ,
                
              
              
                
                  i
                  <
                  
                    
                      X
                      ⁡
                      
                        (
                        b
                        )
                      
                    
                    β
                  
                
              
            
            
              
                
                  0
                  ,
                
              
              
                
                  
                    i
                    ≥
                    
                      
                        X
                        ⁡
                        
                          (
                          b
                          )
                        
                      
                      β
                    
                  
                  ,
                
              
            
          
        
      
    
    
      
        (
        50
        )
      
    
  




assuming that the backlog and observed interference would not change in the following time slot because of an arrival or power updates of the other transmitters. Substituting into (48), we get a variable success probability





  
    
      
        
          
            a
            1
            
              
            
          
          ⁡
          
            (
            
              b
              ,
              i
            
            )
          
        
        =
        
          {
          
            
              
                
                  
                    
                      1
                      α
                    
                    ⁢
                    
                      (
                      
                        1
                        -
                        
                          
                            
                              
                            
                            ⁢
                            
                              βi
                              
                                X
                                ⁢
                                
                                  
                                
                                ⁢
                                
                                  (
                                  b
                                  )
                                
                              
                            
                          
                        
                      
                      )
                    
                  
                  ,
                
              
              
                
                  i
                  <
                  
                    
                      X
                      ⁡
                      
                        (
                        b
                        )
                      
                    
                    β
                  
                
              
            
            
              
                
                  0
                  ,
                
              
              
                
                  
                    i
                    ≥
                    
                      
                        X
                        ⁡
                        
                          (
                          b
                          )
                        
                      
                      β
                    
                  
                  ,
                
              
            
          
        
      
    
    
      
        (
        51
        )
      
    
  




which is sensitive to both backlog and interference.

A second case is that where the probability of successful transmission has the function form




  
    
      
        
          s
          ⁡
          
            (
            
              p
              ,
              i
            
            )
          
        
        =
        
          1
          -
          
            
              e
              
                δ
                ⁡
                
                  (
                  
                    p
                    i
                  
                  )
                
              
            
            .
          
        
      
    
    
      
        (
        52
        )
      
    
  




This generates another family of power control algorithms as follows:

PCMA-2 Algorithms: Each link in the channel updates its power according to the following scheme in consecutive time slots:





  
    
      
        
          p
          
            n
            +
            1
          
        
        =
        
          {
          
            
              
                
                  
                    
                      -
                      
                        
                          i
                          n
                        
                        δ
                      
                    
                    ⁢
                    
                      log
                      ⁡
                      
                        (
                        
                          
                            i
                            n
                          
                          
                            δX
                            ⁡
                            
                              (
                              
                                δ
                                n
                              
                              )
                            
                          
                        
                        )
                      
                    
                  
                  ,
                
              
              
                
                  
                    i
                    n
                  
                  <
                  
                    δ
                    ⁢
                    
                      
                    
                    ⁢
                    
                      X
                      ⁡
                      
                        (
                        
                          b
                          n
                        
                        )
                      
                    
                  
                
              
            
            
              
                
                  0
                  ,
                
              
              
                
                  
                    
                      i
                      n
                    
                    ≥
                    
                      δ
                      ⁢
                      
                        
                      
                      ⁢
                      
                        X
                        ⁡
                        
                          (
                          
                            b
                            n
                          
                          )
                        
                      
                    
                  
                  ,
                
              
            
          
        
      
    
    
      
        (
        53
        )
      
    
  




where X(b) is an increasing function of the transmitter queue backlog. Its particular selection generates a family of algorithms:

Note that under PCMA-2 each transmitter is shooting for the variable SIR target




  
    
      
        
          
            γ
            t
          
          ⁡
          
            (
            
              b
              ,
              i
            
            )
          
        
        =
        
          {
          
            
              
                
                  
                    
                      -
                      
                        1
                        δ
                      
                    
                    ⁢
                    log
                    ⁢
                    
                      δ
                      
                        δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          X
                          ⁡
                          
                            (
                            b
                            )
                          
                        
                      
                    
                  
                  ,
                
              
              
                
                  i
                  <
                  
                    δ
                    ⁢
                    
                      
                    
                    ⁢
                    
                      X
                      ⁡
                      
                        (
                        b
                        )
                      
                    
                  
                
              
            
            
              
                
                  0
                  ,
                
              
              
                
                  
                    i
                    ≥
                    
                      δ
                      ⁢
                      
                        
                      
                      ⁢
                      
                        X
                        ⁡
                        
                          (
                          b
                          )
                        
                      
                    
                  
                  ,
                
              
            
          
        
      
    
    
      
        (
        54
        )
      
    
  




when its backlog is b and the interference is i, hoping that those will not change in the next time slot. That way, it shoots for a probability of success





  
    
      
        
          
            s
            2
          
          ⁡
          
            (
            
              b
              ,
              i
            
            )
          
        
        =
        
          {
          
            
              
                
                  
                    1
                    -
                    
                      δ
                      
                        δ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          X
                          ⁡
                          
                            (
                            b
                            )
                          
                        
                      
                    
                  
                  ,
                
              
              
                
                  i
                  <
                  
                    δ
                    ⁢
                    
                      
                    
                    ⁢
                    
                      X
                      ⁡
                      
                        (
                        b
                        )
                      
                    
                  
                
              
            
            
              
                
                  0
                  ,
                
              
              
                
                  
                    i
                    ≥
                    
                      δ
                      ⁢
                      
                        
                      
                      ⁢
                      
                        X
                        ⁡
                        
                          (
                          b
                          )
                        
                      
                    
                  
                  ,
                
              
            
          
        
      
    
    
      
        (
        55
        )
      
    
  




which is again backlog and interference sensitive. We explore these two families of power control algorithms below and compare their performance to the constant-SIR one.

Remark: Constrained Power. When there is a power ceiling Pmax that the power cannot exceed, both PCMA-1 and PCMA-2 families of algorithms should clip the power at Pmax (when it would have otherwise exceeded it).

Remark: Aggressive, Soft-Backoff, and Hard-Backoff phases of PCMA-1 and PCMA-2: By looking at FIG. 1 and FIG. 3, we see that although PCMA-1 and PCMA-2 have different detailed functional forms, they basically have the same general behavior, which is characterized as follows: Given any fixed backlog b, both algorithms generally have three operational phases that they go through as the interference increases. First, they aggressively try to match and overcome the interference by increasing the power (aggressive phase). Second, as the interference increases beyond some point (different for each algorithm) they start lowering the power, going into a soft-backoff mode, until the transmitted power hits 0 and stays there—then, they go into a hard-backoff mode, as the interference increases further. The intuitive explanation is that, under high interference, there is no point in trying to transmit and spend power, since the chances of being successful drop; therefore, one it is better to back off and wait until the interference subsides. Backing off causes arriving packets to start accumulating in the buffer. That, in turn, raises X(b) and causes the aggressive zone as well as the soft backoff one to spread out in both the PCMA-1 and PCMA-2, which now becomes more aggressive overall (as X(b) increases). This causes packets to be successfully transmitted, which lowers the backlog and deflates X(b) again. This adapted behavior is common to both algorithms and lies at the core of their operation.

To evaluate PCMA-1 and PCMA-2 and compare them to Constant-SIR, we have simulated all three on a sample network which has the following structure. It is a 4×4 square lattice of 16 square cells, with its edges wrapped around to generate a 4×4 torus (in order to avoid any boundary effects). Each square cell has a communication link (16 total). Let Gij be the power gain between the transmitter of the jth link and the receiver of the ith one. We normalize all Gii=1 and use Gij=2/rij2, where rij is the distance between the transmitter of the jth link and the receiver of the ith one. Links are positioned at the centers of the squared cells with a distance between neighbors of size 4. The thermal (ambient) noise is taken to be 1. Time is slotted and the three power control algorithms are simulated on the network.
The probability of success used for all three power control algorithms is that of (48) with α=β=1 (even for PCMA-2). The function X(b)=4+b is used for both PCMA-1 and PCMA-2. The constant 4 is used to keep an acceptable throughput for very small backlogs, so as to suppress excessive delays at very low arrival rates.
FIG. 4 shows the backlog vs. load performance curves of the three algorithms: Constant-SIR, PCMA-1, PCMA-2. It is interesting to observe that Constant-SIR power control can keep the backlog from exploding up to load 0.4 (approx.), while PCMA-1 and PCMA-2 can keep the queue stable up to packet arrival rates 0.5 (approx.). This is a substantial improvement in throughput of about 20%. It is also interesting that both PCMA-1 and PCMA-2 achieve almost the same throughput. This may be due to the similar adapted behavior of both algorithms.
It is interesting to intuitively attempt to explain the above observed behavior. Basically, as the load increases and the transmitters have—most of the time—packets to transmit, the Constant-SIR Algorithm becomes overly aggressive trying to keep a certain SIR. This raises the overall level of interference in the network, which in turn causes the transmitters to increase even further their powers and so on . . . . That way the backlog eventually explodes. Instead, PCMA-1 and PCMA-2—because of their soft and hard backoff capability and adaptive behavior to interference and backlog—do not fall into this trap and utilize the channel better, achieving a higher throughput. If, however, Constant SIR algorithm was willing to adaptively lower temporarily its SIR requirement, when facing congestion and backlog stress, it would be able to trade additional throughput for reduction in other performance parameters. This is a tradeoff that occurs in Adaptive SIR algorithms (which is what PCMA-1 and PCMA-2 basically are).
Finally, by choosing different functions X(b) for PCMA-1 and PCMA-2, say, different p's in X(b)=bp, we can make the algorithms more backlog sensitive vs. power sensitive for a given load. That is by increasing p we can trade off lower backlog for higher average power, at a constant arrival rate (load).
REFERENCES INCORPORATED HEREIN


    [1] G. J. Foschini and Z. Miljanic. A simple distributed autonomous power control algorithm and its convergence. IEEE Tran. On Veh. Tech., 42(4):641-646, 1993.
    [2] J. Zander. Distributed cochannel interference control in cellular radio systems. IEEE Tran. Veh. Tech. 41(3):305-311, 1992.
    [3] N. Bambos, S. C. Chen, and G. J. Pottie. Radio link admission algorithms for wireless networks with power control and active link quality protection. Proceedings of IEEE INFOCOM '95, Boston, Mass., 1995. Extended version: Technical Report #UCLA-ENG-94-25, School of Engineering & Applied Science, University of California at Los Angeles, March 1994.
    [4] D. Mitra. An asynchronous distributed algorithm for power control in cellular radio systems. Proc. of 4th WINLAB Workshop, Rutgers University, NJ 1993.
    [5] D. Bertsekas. Dynamic Programming. Prentice. 1987.
    [6] J. Rulnick, N. Bambos. Mobile Power Management for Wireless Communication Networks. Wireless Networks, v. 3, 1997.
    [7] M. Andersin, Rosberg, J. Zander. Gradual removals in cellular PCS with constrained power control and noise. Wireless Networks, 2(1):27-43, 1996.
    [8] M. Andersin, Z. Rosberg, J. Zander (1995). Soft and safe admission control in cellular networks. IEEE/ACM Transactions in Networking, 5(2):255-265, 1997.
    [9] N. Bambos (1998). Toward Power-Sensitive Network Architectures in Wireless Communications: Concepts, Issues and Design Aspecxts. IEEE Personal Communications Magazine, 5(3):50-59, 1998.
    [10] S. Hanly (1996). Capacity and power control in a spread spectrum macro diversity radio networks. IEEE Tran. On Comm., 44:247-256, 1996.
    [11] R. Yates, C. Y. Huang. Integrated power control and base station assignment. IEEE Tran. Vehic. Tech., 44(3):638-644, 1995.
    [12] R. Yates. A framework for uplink power control in cellular radio systems. IEEEJ. Sel. Areas in Comm., 13(7):1341-1347 (1995).


Also incorporated herein (originally part of this instant patent document) are Appendix A and Appendix B respectively corresponding to two types of example implementations embodying the present invention. Appendix A, entitled “Power Controlled Multiple Access (PCMA) in Wireless Communication Networks,” comprising 10 pages and authored by Nicholas Bambos and Sunil Kandukuri. Appendix B, entitled “Multimodal Dynamic Multiple Access (MDMA) in Power Controlled Wireless Packet Networks,” comprising 11 pages and authored by Sunil Kandukuri and Nicholas Bambos.
The various embodiments described above are provided by way of illustration only and should not be construed to limit the invention. Based on the above discussion and illustrations, those skilled in the art will readily recognize that various modifications and changes may be made to the present invention without strictly following the exemplary embodiments and applications illustrated and described herein. Such changes include, but are not necessarily limited to other network configurations and to other communication arrangements in which a common channel is breached by multiple transmitters. Such modifications and changes do not depart from the true spirit and scope of the present invention that is set forth in the following claims.

## Claims

1. A method for managing a data transmission using a channel in a communication environment susceptible to interference due to another data transmission, comprising:
providing an indication of recent state for the channel;
buffering blocks of data for subsequent transmission;
determining a buffered data backlog cost; and
selecting a transmission mode for use in transmitting at least one of the buffered data blocks as a linear function of a number of buffered data blocks, a function of the buffered data backlog cost and the indication of the recent channel state.

2. The method of claim 1, wherein selecting a transmission mode includes selecting at least two of the following transmission modes: a power level, a modulation scheme, an access point, and a coding scheme.

3. The method of claim 1, wherein selecting a transmission mode as a function of the buffered data further includes selecting a transmission mode as a function of a number of buffered data blocks.

4. The method of claim 1, wherein selecting a transmission mode includes selecting a power level and at least one of the following transmission modes: a modulation scheme, an access point, and a coding scheme.

5. The method of claim 1, wherein the indication of the recent channel state corresponds to a recent indication of channel interference.

6. The method of claim 1, wherein the indication of the recent channel state corresponds to an indication of channel interference of the most recent transmission.

7. The method of claim 1, further including mitigating the interference due to another data transmission by assigning weighting factors to the buffered data blocks and collectively reducing the weighting factors.

8. The method of claim 7, further including assigning a cost to each of the buffered data blocks.

9. The method of claim 7, wherein collectively reducing the weighting factors includes controlling power levels for data transmission in consecutive time slots.

10. The method of claim 1, wherein the step of determining the buffered data backlog cost includes determining a number of buffered blocks of data for subsequent transmission.

11. The method of claim 10, wherein the step of the buffered data backlog cost includes a cost for buffer overrun.

12. The method of claim 10, wherein the step of determining the buffered data backlog cost includes a transmission deadline for at least one buffered block of data.

13. The method of claim 1, wherein the step selecting a transmission mode includes reducing the transmission power in response to channel interference of the most recent transmission exceeding a level.

14. A system for managing data transmissions wherein one channel is used in a communication environment susceptible to interference due to another data transmission, comprising:
means for providing an indication of recent state for the channel and determining a buffered data backlog cost;
means for buffering blocks of data for subsequent transmission; and
means for selecting a transmission mode for use in transmitting at least one of the buffered data blocks as a linear function of a number of buffered data blocks, a function of the buffered data backlog cost and the indication of the recent channel state.

15. A system for managing data transmissions wherein one channel is used in a communication environment susceptible to interference due to another data transmission, comprising:
a first data processing block adapted to provide an indication of recent state for the channel and determining a buffered data backlog cost;
a second data processing block adapted to buffer blocks of data for subsequent transmission; and
a third data processing block adapted to select a transmission mode for use in transmitting at least one of the buffered data blocks as a function of the buffered data backlog cost and the indication of the recent channel state and linear function of a number of buffered data blocks.

16. The system of claim 15, further including a transmitting station adapted to transmit the data in modulated wireless form.

17. The system of claim 15, further including a plurality of transmitting stations, each adapted to transmit the data in modulated wireless form using a common communication channel.

18. The system of claim 15, further including a plurality of transmitting stations, each adapted to transmit the data in modulated wireless form using a common communication channel, and wherein each of the plurality of transmitting stations includes a first data processing block, a second data processing block, and a third data processing block.

19. The system of claim 18, wherein each of the plurality of transmitting stations is programmed to execute each of the first data processing block, the second data processing block, and the third data processing block independent of each other of the plurality of transmitting stations.

20. The system of claim 15, wherein a transmission mode selection includes at least two of the following transmission modes selections: a power level, a modulation scheme, an access point, and a coding scheme.

21. The system of claim 15, wherein a transmission mode is selected as a function of a number of buffered data blocks.

22. The system of claim 15, wherein a power level and at least one of the following transmission modes are selected: a modulation scheme, an access point, and a coding scheme.

23. The system of claim 15, wherein the indication of the recent channel state corresponds to a recent indication of channel interference.

24. The system of claim 15, wherein the indication of the recent channel state corresponds to an indication of channel interference of the most recent transmission.

25. The system of claim 15, further including wherein the interference due to another data transmission is mitigated by assigning weighting factors to the buffered data blocks and collectively reducing the weighting factors.

26. The system of claim 25, further including a processing block adapted to assign a cost to each of the buffered data blocks.

27. The system of claim 25, wherein the weighting factors are collectively reduced by controlling power levels for data transmission in consecutive time slots.

28. The system of claim 25, wherein each of the data processing blocks is in a single base station adapted to transmit using a first channel.

29. The system of claim 28, further including additional base stations adapted to transmit using the same first channel.

30. The system of claim 29, wherein each of the additional base stations includes similarly arranged first, second and third data processing blocks.

31. The system of claim 15, wherein the buffered data backlog cost corresponds to a number of buffered blocks of data for subsequent transmission.

32. The system of claim 31, wherein the buffered data backlog cost includes a cost for buffer overrun.

33. The system of claim 31, wherein the buffered data backlog cost includes a transmission deadline for at least one buffered block of data.