# Patent

## Title
Distributed resource allocation in stream processing systems

## Abstract

A system and method for resource allocation includes, in a network having nodes and links, injecting units of flow for at least one commodity at a source corresponding to the at least one commodity. At each node, queue heights, associated with the at least one commodity, are balanced for queues associated with each of one or more outgoing paths associated with that node. An amount of commodity flow is pushed across a link toward a sink, where the amount of commodity flow is constrained by a capacity constraint. Flow that reached the sink is absorbed by draining the queues.

## Background
RELATED APPLICATIONS INFORMATION
This application is a continuation of co-pending U.S. patent Ser. No. 11/472,843, filed Jun. 22, 2006, which is incorporated by reference herein in its entirety.


BACKGROUND
1. Technical Field
The present invention relates to resource allocation in distributed stream processing, and more particular to systems and methods for more efficiently allocating system resources in distributed networks or systems.
2. Description of the Related Art
The rapid development of computer technology has enabled streaming applications to emerge from many areas of the information technology (IT) industry. Examples of the broad application areas include network traffic monitoring, real-time financial data analysis, environmental sensing, surveillance, etc. In these applications, multiple data streams are generated by a large number of distributed sources, such as news and financial data feeds, monitoring sensors and surveillance video/audio sources. In order to provide valuable services to the users, these continuous streams of data need to pass through a series of sophisticated processing operations, including filtering, aggregation, and translation, etc.
Large distributed computer systems are often built to provide scalable processing services for the large amount of continuous data. The distributed stream processing systems, together with the data sources, and other shared resources, such as Internet hosts and edge servers, are connected by a network and collectively provide a rich set of processing services. The requirements to process large volumes of real-time data at high rates, and to effectively coordinate multiple servers in a distributed environment, have led to many great design challenges for efficient stream processing systems.
A fundamental problem in such stream-based processing networks is how to best utilize the available resources and coordinate seamlessly so that the overall system performance is optimized.
In most stream processing systems, applications are often running in a decentralized, distributed environment. At any given time, no server has the global information about all the servers in the system. It is thus difficult to determine the best resource allocation policy at each server in isolation, such that the overall throughput of the whole system is optimized. In addition to reaching the global optimal performance, the system needs to be able to adapt to the dynamically changing environment including input and resource consumption fluctuations. The system needs to coordinate the processing, communication, storage/buffering, and the input/output of neighboring servers to meet these challenging requirements.
Much stream processing related work has been done on data models and operators and efficient processing. While resource management has been noticed to be important to the performance, most work has focused on either heuristics for avoiding overload or simple schemes for load-shedding. The problem of dynamic load distribution and resource allocation has not yet been fully studied.
SUMMARY
The present embodiments consider a distributed resource allocation problem for a network of servers, constrained in both computing resources and link bandwidth. A model captures the shrinkage and expansion characteristics peculiar to stream processing, which generalizes the flow network. A novel expanded graph representation is provided that unifies the two types of resources seamlessly. The original problem is then mapped to a generalized multicommodity flow problem.
Three variations of the resource allocation problem are illustratively considered with distributed methods to solve the problems. The methods provide optimality in all three cases. An analysis on the complexity and how the methods adapt to dynamic changes are described. Numerical experiments were conducted to demonstrate that the distributed algorithms work well.
A method for resource allocation includes, in a network having nodes and links, injecting units of flow for at least one commodity at a source corresponding to the at least one commodity. At each node, queue heights, associated with the at least one commodity, are balanced for queues associated with each of one or more outgoing paths associated with that node. An amount of commodity flow is pushed across a link toward a sink, where the amount of commodity flow is constrained by a capacity constraint. Flow that reached the sink is absorbed by draining the queues.
In other embodiments, methods include determining a maximum concurrent flow rate for a plurality of commodities, by: initializing a maximum concurrent flow rate variable and an error tolerance value; performing the steps as recited in claim 1 until a number of iterations exceeds T or a queue threshold is exceeded due to the maximum concurrent flow rate variable; if T iterations have been exceeded without exceeding a queue threshold, increasing the maximum concurrent flow rate variable; and bisecting the maximum concurrent flow rate variable until a criterion is met to maximize concurrent flow rate. In still other embodiments, the method includes balancing all queue heights for the at least one commodity to equal heights and deleting any excess flow so that every queue in the node has a height of no more than a buffer size (H).
A resource allocation system includes at least one queue corresponding to one or more outgoing paths. An input path is configured to receive one or more commodities in a distributed network. A resource allocation program is configured to balance queue heights for flow units injected in the queues associated with the at least one commodity, and is further configured to push an amount of commodity flow across a link toward at least one sink. The amount of commodity flow is constrained by a capacity constraint.
These and other objects, features and advantages will become apparent from the following detailed description of illustrative embodiments thereof, which is to be read in connection with the accompanying drawings.



BRIEF DESCRIPTION OF DRAWINGS
The disclosure will provide details in the following description of preferred embodiments with reference to the following figures wherein:
FIG. 1 is a block diagram of a network of nodes/servers configured to perform resource allocation in accordance with present principles;
FIG. 2 is a block diagram showing a task graph in accordance with present principles;
FIG. 3 is a block diagram showing a physical server graph in accordance with present principles;
FIG. 4 is an expanded graph representation to demonstrate a problem solved in accordance with present principles;
FIG. 5 is a diagram showing queue heights for input and outputs at edges in a network in accordance with present principles;
FIG. 6 is a block/flow diagram showing method 1 for solving a feasibility problem for resource allocation in accordance with present principles;
FIG. 7 is a diagram schematically showing a reverse water filling method for solving problems in accordance with present principles;
FIG. 8 is a block/flow diagram showing method 2 for solving a maximum concurrent flow problem for resource allocation in accordance with present principles;
FIG. 9 is a block/flow diagram showing method 3 for solving a maximum weighted flow problem for resource allocation in accordance with present principles;
FIG. 10 is a diagram showing a randomly generated network for testing in accordance with present principles;
FIG. 11A is a diagram showing convergence to a desirable flow using the feasibility approach in accordance with present principles;
FIG. 11B is a diagram showing computational time for reaching convergence in FIG. 11A in accordance with present principles; and
FIG. 12 is a diagram showing convergence to a desirable flow using the maximum weighted flow approach in accordance with present principles.



DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS
Embodiments in accordance with present principles consider a distributed stream processing system which includes a network of cooperating servers, collectively providing processing services for multiple concurrent stream-based applications. Each application needs sophisticated processing of data streams from dispersed sources in a near real-time manner. The performance of such stream processing systems depends on an effective distribution of the available processing resources to the variety of data streams over the multiple, cooperating servers. Assuming all servers have finite computing resources and all communication links have finite available bandwidth, a generalized multi-commodity flow model is presented for the above-described allocation problem. Distributed methods are provided for finding the best resource allocation schemes in such stream processing networks.
Detailed performance analysis on the optimality and complexity of these methods are also provided. Numerical experiments are presented to demonstrate that these distributed algorithms work well.
In particularly useful embodiments, a distributed stream processing system is considered that includes a network of cooperating servers, collectively providing processing services for multiple data streams from geographically dispersed sources. In this illustrative system, each stream is needed to complete a series of tasks (operations) to become a finished product and leave the system. Each server is responsible for a subset of the tasks for possibly a subset of streams. It is possible for the size of the data streams to change after each operation. For example, a filtering operation may shrink the stream size dramatically, while a decryption operation may expand the stream size.
The traditional flow balancing properties no longer hold due to the shrinkage and expansion effects. This makes a corresponding flow network in accordance with present principles different from the conventional flow network. All servers are assumed to have finite computing resources and all communication links are assumed to have finite available bandwidth. This is to simplify the problem to demonstrate the present principles.
Each server operates independently of other servers except for communicating with its neighbors to transmit finished data streams. The present disclosure aims to find distributed schemes to allocate the computing resources as well as the communication bandwidth for the multiple streams and multiple servers so as to maximize the overall throughput for the whole system.
In particularly useful embodiments, three variations of the resource allocation problem are considered. The feasibility problem answers the question of whether the system has enough capacity to process the incoming streams at a given set of input rates. The maximum concurrent flow problem seeks to achieve a maximum proportional throughput for all output streams. The maximum weighted flow problem obtains the best allocation of the resources so that the total value of the output streams is maximized, where associated with each stream, there is a given weight to represent the value of return for every unit of successively delivered output. These three related problems are solved based on a distributed algorithm with customized features to address the slightly different objectives.
The method in accordance with present principles is based on setting up buffers and using back-pressure governed by potential functions to move flows across various servers and communication links. The analysis is provided for the optimality and complexity of the algorithms. Experimental results are then presented to demonstrate the performance of the algorithms as the network size scales up.
The problem can be described as a generalization of the traditional multicommodity flow problem. Multicommodity flow problems have been studied extensively in the context of conventional flow networks. The traditional multicommodity flow problem looks for the best way of using the link capacities to deliver the maximum throughput for the flows in the whole network. In addition to the link bandwidth constraints, the present principles include processing power constraints for each server. Furthermore, the traditional flow balancing is generalized in the presently addressed problem so as to allow flow shrinkage or expansion. The existing distributed algorithms are extended for the multicommodity problem to account for these differences and prove the same kind of convergence and complexity results.
Embodiments of the present invention can take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment including both hardware and software elements. In a preferred embodiment, the present invention is preferably implemented in software, which includes but is not limited to firmware, resident software, microcode, etc.
Furthermore, the invention can take the form of a computer program product accessible from a computer-usable or computer-readable medium providing program code for use by or in connection with a computer or any instruction execution system. For the purposes of this description, a computer-usable or computer readable medium can be any apparatus that may include, store, communicate, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device. The medium can be an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system (or apparatus or device) or a propagation medium. Examples of a computer-readable medium include a semiconductor or solid state memory, magnetic tape, a removable computer diskette, a random access memory (RAM), a read-only memory (ROM), a rigid magnetic disk and an optical disk. Current examples of optical disks include compact disk-read only memory (CD-ROM), compact disk—read/write (CD-R/W) and DVD.
A data processing system suitable for storing and/or executing program code may include at least one processor coupled directly or indirectly to memory elements through a system bus. The memory elements can include local memory employed during actual execution of the program code, bulk storage, and cache memories which provide temporary storage of at least some program code to reduce the number of times code is retrieved from bulk storage during execution. Input/output or I/O devices (including but not limited to keyboards, displays, pointing devices, etc.) may be coupled to the system either directly or through intervening I/O controllers.
Network adapters may also be coupled to the system to enable the data processing system to become coupled to other data processing systems or remote printers or storage devices through intervening private or public networks. Modems, cable modem and Ethernet cards are just a few of the currently available types of network adapters.
Referring now to the drawings in which like numerals represent the same or similar elements and initially to FIG. 1, a resource allocation system 10 in a distributed environment is illustratively shown. System 10 includes nodes/servers 16. Each node 16 may include a plurality of queues or buffers 17 corresponding to one or more outgoing paths from the node 16. An input path is configured to receive one or more commodities or streams 12 and 14 in the distributed network. A resource allocation program 19 is configured to balance queue heights (buffers capacities) for flow units injected in the queues associated with the at least one commodity or stream. The resource allocation program 19 provides the ability to allocate the outgoing information in a way that optimizes information flow through the network. For example, resource allocation program 19 executes methods 1, 2 and 3 (e.g., to solve for feasibility, maximum flow and/or weighted maximum flow or other methods) as will be described in greater detail below.
Resource allocation program 19 pushes an amount of commodity flow across a link toward at least one sink, where the amount of commodity flow is constrained by a capacity constraint, such as bandwidth of the links or capacity of the node/server. The buffers/queues 17 use back-pressure governed by potential functions to move flows across various servers and communication links. For example, the resource allocation program 19 includes a potential function which determines adjustments to the queue heights for reducing a total potential for all queues. The resource allocation program 19 may further include a reverse water filling method to identify a threshold for balancing the queue heights in accordance with the capacity constraint.
One aspect of the present system 10 includes that the node 16 allocates resources through itself without awareness of resource allocation information of other nodes. In one embodiment, all that is needed from other nodes is an awareness of buffer sizes of neighboring nodes.
A distributed stream processing environment is considered with dispersed data sources that provide high-volume data streams 12 and 14 to be consumed by multiple applications (tasks) in real time. The system 10 may include a large number of servers 16, capable of executing multiple stream-oriented programs/tasks 18. These servers 16 are possibly geographically distributed, and are connected through communication links 20. Each server 16 only has knowledge about its neighboring servers 16. All of these servers 16 collectively provide processing services for multiple concurrent stream-based applications.
It is assumed that each data stream 12 and 14 needs to be processed according to a given sequence of tasks 18, which are already pre-loaded onto various servers. Different servers 16 may be responsible for a different set of tasks (possibly overlapping) based on different platform requirements and other physical constraints. Multiple tasks residing on the same server can be executed in parallel and share the computing resource. It is the system's decision to invoke different servers for different streams and to allocate resources accordingly.
Besides being limited in computing resources at each server 16, the system 10 is also constrained in communication bandwidth on all the links. Multiple outgoing (processed) flows sharing the same physical link will compete for the finite communication bandwidth. Hence, each server 16 is faced with two decisions: first, it has to decide the allocation of its computing resource to multiple processing tasks; second, it has to decide how to share the bandwidth on each output link among the multiple flows going through.
The overall system 10 throughput depends on the coordination of processing, communication, buffering/storage, and input and output of various interconnected servers. In addition, such coordination/allocation schemes have to be distributed and be adaptive to the dynamically changing network environment. Two types of graphs may be employed to describe the logical and physical relationships between the streams, the processing tasks and the servers.
Referring to FIG. 2, a task sequence graph is depicted and describes logical relationships among the processing tasks 30 for each data stream S1 and S2 in this example. The processing for each data stream (12 and 14) includes a series of tasks 30 (labeled A-H). Stream S1 needs processing of task A, followed by tasks B, C, D. Stream S2 needs processing of task C, followed by tasks E, F and H.
Referring to FIG. 3, a physical server graph is used to describe the relationship among physical servers 16 and communication links 20 based on the task sequence graph of FIG. 2. Each server 16 is assigned to process one task 30 for each data stream 12 and 14. Notice that a task 30 may be assigned to multiple servers 16, and tasks 30 that belong to different streams 12 and 14 may be assigned to the same server 16. The placement of the various tasks 30 onto a physical network 40 may be handled using known techniques. For purposes of this disclosure, it is assumed that the task to physical server assignment is given.
It is reasonable to assume that on a given server 16, each task 30 corresponds to a different stream 12 or 14. E.g., if tasks A and C are both assigned to server 1, task B will be assigned to server 1 so as to save communication bandwidth. A task sequence graph of a stream can then be mapped to a directed acyclic sub-graph in the physical server graph. For example, suppose there are eight servers 16 (labeled servers 1-8 in FIG. 3), with server 1 assigned for task A, server 2 for task B, server 3 for tasks B and E, server 4 for task C, server 5 for tasks C and F, server 6 for task D, server 7 for task G, and server 8 for task H. Then, the directed acyclic sub-graph of the physical network of FIG. 3 shows tasks 30 which are represented by rectangles and servers 16 by circles. The sub-graph composed of solid links corresponds to stream S1 (12) and the sub-graph composed of dashed links corresponds to stream S2 (14). It is easily verified that the sub-graphs corresponding to individual streams are directed acyclic graphs.
The above physical network in FIG. 3 can he represented by a generic graph G=(N, E). Set N includes source nodes, sink nodes and processing nodes. Directed edges represent possible information flow between various nodes. The source nodes correspond to the source of the input data streams. These nodes only have edges going out, and do not have any edges between them. The sink nodes correspond to the receivers of the eventual processed information. These nodes only have edges going to them, and do not have any edges in between. These different types of eventual processed information may be referred to as commodities. The commodities correspond to different types of services or products provided by the multiple concurrent applications on the system.
Assume that there are K different types of commodities, each associated with a unique sink node tk, k=1, . . . , K. Processing nodes stand for the various processing servers. They have both incoming and outgoing edges. An edge (u, v)∈ε for server v indicates that there should be a task residing on server v that can handle data output from node u. For a given node u, denote I(u) the set of all predecessor nodes of node u, and O(u) the set of all successor nodes of node u.
Without loss of generality, it can be assumed that each source node produces a single stream as the input to some processing node, and there is exactly one output stream leading to each sink node. Graph G is assumed to be connected. Each processing node u has available computing resource Ru (≦∞). Each pair {u, v} of connected nodes has a finite bandwidth Buv available for communication.
Quantitative relationships will now be described between the input, output and resource consumption. Assume that the processing of one commodity stream is independent of the processing of other commodities, although the processing streams may share some common computing/communication resources. Also assume that it takes computing resource ru,vk for node u∈N to process 1 unit of commodity k flow for downstream node v with v∈O(u). Each unit of commodity k input will result in βu,vk(>0) units of output after processing. This β parameter only depends on the task being executed for its corresponding stream. For example in FIG. 3, the fact that task B of stream 1 can be executed on both server 2 and server 3 indicates:

β2,51=β3,51=β2,41=β3,41.

The parameter βu,vk will be referred to as an expansion factor, which represents the expansion (or shrinking) effect in stream processing. For example, a decryption task may have a large expansion effect with βu,vk>1, while a filtering task may have a shrinking effect with βu,v<1. Thus, flow conservation does not hold in the processing stage. However, flow is conserved while being transferred across an edge. Transferring a unit of flow across an edge needs one unit of bandwidth.
Without loss of generality, assume each server 16 can produce output flows for all downstream servers 16 from its incoming flows. In case one type of commodity k flow does not go to a downstream server v from server u, simply set ru,vk=+∞, βu,vk=1. Consider the example in FIG. 3, the fact that server 3 cannot send stream 2 to server 4 is equivalent to setting r3,4k=+∞, βu,vk=1 such that server 3 will take an infinite amount of resources to process flow for server 4.
It is possible for a stream to travel along different paths to reach the sink. The resulting outcome does not depend on the processing path in the physical network. However, the resource consumption can be different along different paths. Part of the problem is to determine the most efficient ways to utilize the resources. This leads to the following properties on the β parameters.
Property 1: For any two distinct paths p=(n0, n1, . . . , nl) and p′=(n0′, n1′, . . . nl′′) that have the same starting and ending points, i.e. n0=n0′ and n0′=nl′′, we have:




  
    
      ∏
      
        i
        =
        0
      
      
        l
        -
        1
      
    
    ⁢
    
      
    
    ⁢
    
      β
      
        
          n
          
            i
            ,
          
        
        ⁢
        
          n
          
            i
            +
            1
          
        
      
      k
    
  
  =
  
    
      ∏
      
        i
        =
        0
      
      
        
          l
          
            
              
            
            ′
          
        
        -
        1
      
    
    ⁢
    
      
    
    ⁢
    
      β
      
        
          n
          i
          ′
        
        ,
        
          n
          
            i
            +
            
              1
              ′
            
          
          ′
        
      
      k
    
  




for any commodity k that satisfies:




  
    
      
        ∑
        
          i
          =
          0
        
        
          l
          -
          1
        
      
      ⁢
      
        
      
      ⁢
      
        r
        
          
            n
            i
          
          ,
          
            n
            
              i
              +
              1
            
          
        
        k
      
    
    <
    
      +
      ∞
    
  
  ,
  
    
  
  ⁢
  and








  
    
      ∑
      
        i
        =
        0
      
      
        l
        ′
      
    
    ⁢
    
      
    
    ⁢
    
      r
      
        
          n
          i
          ′
        
        ,
        
          n
          
            i
            +
            
              1
              ′
            
          
          ′
        
      
      k
    
  
  <
  
    +
    
      ∞
      .
    
  




That is, no matter which path it takes, a successful delivery of f amount of commodity k flow from source sk to node n will result in the same amount gnkf of output at node n, where gnk is the product of the βu,vk's along any path from sk to n. Clearly, gskk=1. For simplicity, denote gk=gtkk.

Each unit of commodity k that successfully reached the sink node tk is awarded a benefit amount of wk. One goal is to find the optimal or close to optimal schemes to distribute the processing of the variety of data streams over the multiple, cooperating servers subject to finite computing resource and communication bandwidth so as to maximize the total value for all commodities. There are many different metrics to measure the value, e.g., throughput, loss, delay, etc. The metrics considered herein are preferably a function of the throughput of the output streams, however of criteria may be employed within the present principles.
For the problem to make intuitive sense, assume all the parameters R,B,r,β and w to be positive. In general, quantities βu,vk, although measurable, are not deterministic. The βu,vk quantities may depend on the input data. Unless specifically stated otherwise, assume that this dependence is stationary, and that the quantities βu,vk are defined as the average production rates. Distributed solutions capable of adapting to or absorbing local changes are sought in production rates and in network conditions.
Referring to FIG. 4, an extended graph representation and multicommodity model will now be described. An expanded graph representation is provided in FIG. 4 to further illustrate graphically the fact that a processing stage is separate from a flow transfer stage. A bandwidth node is introduced, denoted as nuv, for each pair of servers u and v that are connected (i.e. either (u, v)∈ε, or (v, u)∈ε or both). If previously (u,v)∈ε, then in the new graph, there is a directed edge (u, nuv) from u to nuv, and a directed edge (nuv,v) from nuv to v. The role of the bandwidth node nuv is to transfer flows.
Assume that each bandwidth node has total ‘virtual computing’ resource Rnuv=Bu,v. The virtual computing corresponds to the transfer of the actual flow. Each unit of flow consumes one unit of bandwidth, and will become one unit of flow for the downstream node. In other words, βuuv,vk=1, rnu,v,vk=1. Edges and parameters can he added similarly if (u, v)∈ε. For a processing node u∈N, and commodity k, with resource ru,uuvk=ru,vk, node u can process 1 unit of commodity k flow and produce βu,nuvk=βu,vk unit of commodity k output to node nuv.
Therefore a new (expanded) graph representation, denoted as G′=(N′,ε′) is provided in FIG. 4, where N′ includes two sets of nodes, processing nodes in N and bandwidth nodes in NB. ε′ includes two sets of edges, edges from processing nodes to bandwidth nodes and edges from bandwidth nodes to processing nodes. Clearly, after the expansion, an original graph with N nodes, M edges and K commodities would result in a new graph G′ with N+M nodes, 2M edges and K commodities.
Denote I′(n) the set of all predecessor nodes and O′(n) the set of all successor nodes of node n∈G′. For either processing nodes or bandwidth nodes, processing 1 unit of commodity k flow for edge (n/n′)∈G′ means pushing 1 unit of flow across edge (n, n′). However, after crossing the edge, the flow will result in βu,n′k units of flow at node n′ due to the expansion factor βu,n′k.
The new system, represented by graph G′ in FIG. 4, is then faced with a unified problem (multicommodity flow problem): finding efficient ways of shipping all K commodity flows to their respective destinations subject to the resource constraint at each node. The new graph G′ of FIG. 4 will be referred to hereinafter.
Static Problem Formulation: The problem described above can be viewed as a multicommodity flow problem. The traditional multicommodity flow problem consists of shipping several different commodities from their respective sources to their sinks through a common network so that the total flow going through each edge does not exceed its capacity. Associated with each commodity is a demand, which is the amount of that commodity that we wish to ship through the network. The problem comes in several verities. In the first, it would desirable to know if there is a feasible flow, i.e. a way of shipping the commodities that satisfies the demands. It would desirable to know the maximum value z such that z percent of each demand can be satisfied. This is called the maximum concurrent flow problem. Lastly, known as the maximum multicommodity flow problem, maximize the total flow over all commodities.
In present examples, the capacity constraints are on the nodes instead of edges. That is, the present embodiments are interested in efficient ways of shipping the multicommodity flows to their respective destinations subject to the node resource constraints. Also notice that traditional multicommodity flow problems assume flow conservation. This assumption no longer holds in the context of stream processing networks. In present embodiments, a unit of commodity k flows at node n, and once across edge (n,n′) in graph G′, will become βn,n′k, units of commodity k flow at node n′.
Three different varieties of the problem are of interest: 1) the feasibility problem, 2) the maximum concurrent problem, and 3) the maximum weighted flow problem. Denote xu,n′k, the amount of commodity k flow to be processed at node n∈N′ that will generate output to downstream node n′∈O′(n). A feasible solution has to satisfy the following conditions:

xn,n′k≧0,∀k;n,n′∈N′  (1)





  
    
      
        
          
            
              ∑
              k
            
            ⁢
            
              
            
            ⁢
            
              
                ∑
                
                  
                    n
                    ′
                  
                  ∈
                  
                    
                  
                  ⁢
                  
                    
                      O
                      ′
                    
                    ⁡
                    
                      (
                      n
                      )
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  x
                  
                    n
                    ,
                    
                      n
                      ′
                    
                  
                  k
                
                ⁢
                
                  r
                  
                    n
                    ,
                    
                      n
                      ′
                    
                  
                  k
                
              
            
          
          ≤
          
            R
            n
          
        
        ,
        
          ∀
          
            
          
          ⁢
          
            n
            ∈
            
              N
              ′
            
          
        
      
    
    
      
        (
        2
        )
      
    
  




and for all k and n∈N′,




  
    
      
        
          
            
              ∑
              
                
                  n
                  ′
                
                ∈
                
                  
                    O
                    ′
                  
                  ⁡
                  
                    (
                    n
                    )
                  
                
              
            
            ⁢
            
              
            
            ⁢
            
              x
              
                n
                ,
                
                  n
                  ′
                
              
              k
            
          
          -
          
            
              ∑
              
                
                  n
                  ′′
                
                ∈
                
                  
                
                ⁢
                
                  
                    l
                    ′
                  
                  ⁡
                  
                    (
                    n
                    )
                  
                
              
            
            ⁢
            
              
            
            ⁢
            
              
                x
                
                  
                    n
                    ′′
                  
                  ,
                  n
                
                k
              
              ⁢
              
                β
                
                  
                    n
                    ′′
                  
                  ,
                  n
                
                k
              
            
          
        
        =
        
          {
          
            
              
                
                  
                    f
                    k
                  
                  ,
                  
                    
                      if
                      ⁢
                      
                        
                      
                      ⁢
                      n
                    
                    =
                    
                      s
                      k
                    
                  
                
              
            
            
              
                
                  
                    
                      -
                      
                        g
                        k
                      
                    
                    ⁢
                    
                      f
                      k
                    
                  
                  ,
                  
                    
                      if
                      ⁢
                      
                        
                      
                      ⁢
                      n
                    
                    =
                    
                      t
                      k
                    
                  
                
              
            
            
              
                
                  0
                  ,
                  otherwise
                
              
            
          
        
      
    
    
      
        (
        3
        )
      
    
  




Conditions (1) and (2) ensure respectively the non-negativity requirement on the assignment and the resource constraint on each node. Condition (3) represents the flow balance requirements such that incoming flows arrive at the same rate as outgoing flows being consumed at each node for each commodity. Note that such balance holds only on the nodes, not when the flow is shipped across edges.
The three different varieties of the problem can be then formulated as the following linear programs respectively:
1. The feasibility problem for demand dk,k=1 . . . , K
[PF] fk=dk, ∀k; subject to (1)-(3).
That is, a feasible solution will successfully consume dk units of commodity k flow per unit time at source k for commodity k, k=1, . . . , K.
2. The maximum concurrent flow problem is:
[PC] max δ subject to fk=δdk,∀k and (1)-(3).
where dk are given. That is, the problem will find the maximum fraction δ so that the network is feasible with input rates δdk for commodity k,k=1, . . . , K.
3. The maximum weighted flow problem (given the maximum input rate at source k is λk, k=1, . . . , K) is:




  
    [
    PM
    ]
  
  ⁢
  
    
  
  ⁢
  max
  ⁢
  
    
      ∑
      
        k
        -
        1
      
      k
    
    ⁢
    
      
    
    ⁢
    
      
        w
        k
      
      ⁢
      
        g
        k
      
      ⁢
      
        f
        k
      
    
  




subject to fk≦λk,∀k; and (1)-(3).

That is, the problem is to maximize the total weighted sum of return of all outputs for all commodities.
Problem 1 is useful in finding solutions for a targeted throughput. Problem 2 makes sense when the demand proportions for multiple applications are fixed (e.g. in a mature market) and the system gives a fair effort for all applications. Problem 3 is favored for a service provider, which maximize the total benefit by efficiently allocating its resources among the multiple services.
These linear programs represent centralized solutions. The linear problems can serve to provide the theoretical optimum so that the quality of the distributed solutions can be determined. In the following, distributed solutions for the three problems are provided.
Feasibility Problem: The feasibility problem [PF] consumes dk units of commodities k (per unit of time) at source k, k=1, . . . , K. Consider the time evolution of the network as proceeding in a sequence of synchronous rounds, each lasting for unit time. The continuous feasible flow problem will be solved by interpreting it as a flow problem in which source sk pumps dk units of commodity k flow into the system in each round. A method for the continuous flow problem will be considered to be stable if the total amount of flow residing in the system at any time remains bounded. Clearly, such an algorithm or method is able to deliver the injected flow in the long run. Construct a feasible flow for problem [PF] using the average of the continuous solution. The notation used includes reference to edges, means directed edges. An input and an output queue are maintained for each commodity at the tail and the head of each edge e∈ε, denoted as buffer Qk(eh) and Qk(et) respectively for commodity k. Denote qk(eh) and Qk(et) as the amount of flow (or height) respectively in buffer Qt(eh) and Qk(et). Let qk(eh)=qk(eh)/dk and qk(et)=qk(et)/dk be the relative heights (normalized by the demand). FIG. 5 illustratively depicts input and output buffers/queues 55 and 57, respectively, associated with each edge e (or link in a network).
Distributed Solution: A potential function Φ( q) associated with every queue is defined, where q is the (relative) height. In general, the potential function needs to be twice-differentiable and convex. With these properties, the total potential function of n queues of heights q1, . . . , qn, defined as




  
    
      Φ
      ⁡
      
        (
        
          
            q
            1
          
          ,
          ...
          ⁢
          
            
          
          ,
          
            q
            n
          
        
        )
      
    
    =
    
      
        ∑
        
          i
          =
          1
        
        n
      
      ⁢
      
        
      
      ⁢
      
        Φ
        ⁡
        
          (
          
            q
            i
          
          )
        
      
    
  
  ,




is Schur Convex, as is known in the art. Thus, the more balanced the queues are, the lower the total potential. For example, for





  
    
      Φ
      ⁡
      
        (
        y
        )
      
    
    =
    
      
        y
        2
      
      2
    
  
  ,




it is easily checked that





  
    
      y
      1
      2
    
    +
    ...
    +
    
      y
      n
      2
    
  
  ≥
  
    
      
        n
        ⁡
        
          (
          
            
              
                y
                1
              
              +
              ...
              +
              
                y
                n
              
            
            n
          
          )
        
      
      2
    
    .
  




In this disclosure, consider the illustrative potential function





  
    Φ
    ⁡
    
      (
      y
      )
    
  
  =
  
    
      
        y
        2
      
      2
    
    .
  




Other efficient methods may include other potential functions such as, e.g., the exponential function.

Specifically, for any edge e and commodity k, define Φk(e)=Φ( qk(et))+Φ( qk(eh)).
Define the potential of a given node n∈N′ as




  
    
      Φ
      ⁡
      
        (
        n
        )
      
    
    =
    
      
        ∑
        
          k
          =
          1
        
        K
      
      ⁢
      
        
          ∑
          
            
              n
              ′
            
            ∈
            
              
                O
                ′
              
              ⁡
              
                (
                n
                )
              
            
          
        
        ⁢
        
          
            Φ
            k
          
          ⁡
          
            (
            
              e
              
                n
                ,
                
                  n
                  ′
                
              
            
            )
          
        
      
    
  
  ,




where en,n′ denotes edge (n,n′). The potential of the entire system, Φ, is simply Φ=Σn∈N′Φ(n).

Referring to FIG. 6, the following (distributed) method is provided to find the feasible solution, inspired by the well-known Awerbuch-Leighton Algorithm. In each round of the method, the following four phases are performed.
Method 1 (for the Feasibility Problem): In block 202 (phase 1), for each commodity k, inject dk units of flow at its corresponding source sk. In block 204 (phase 2), balance all queues for commodity k at node n to equal heights. In block 206, (phase 3), for every node n∈N′, push xn,n′k≧0 amount of commodity k flow across edge (n,n′) for all n′∈O′(n), (let en,n′ denote the edge (n,n′)), so that




  
    
      
        
          ∑
          k
        
        ⁢
        
          
            ∑
            
              
                n
                ′
              
              ∈
              
                
                  O
                  ′
                
                ⁡
                
                  (
                  n
                  )
                
              
            
          
          ⁢
          
            ⌊
            
              
                Φ
                ⁡
                
                  (
                  
                    
                      
                        
                          q
                          _
                        
                        k
                      
                      ⁡
                      
                        (
                        
                          e
                          
                            n
                            ,
                            
                              n
                              ′
                            
                          
                          t
                        
                        )
                      
                    
                    -
                    
                      
                        x
                        _
                      
                      
                        n
                        ,
                        
                          n
                          ′
                        
                      
                      k
                    
                  
                  )
                
              
              +
              
                Φ
                ⁡
                
                  (
                  
                    
                      
                        
                          q
                          _
                        
                        k
                      
                      ⁡
                      
                        (
                        
                          e
                          
                            n
                            ,
                            
                              n
                              ′
                            
                          
                          h
                        
                        )
                      
                    
                    +
                    
                      
                        β
                        
                          n
                          ,
                          
                            n
                            ′
                          
                        
                        k
                      
                      ⁢
                      
                        
                          x
                          _
                        
                        
                          n
                          ,
                          
                            n
                            ′
                          
                        
                        k
                      
                    
                  
                  )
                
              
            
            ⌋
          
        
      
    
    
      
        (
        4
        )
      
    
  




is minimized under the constraint that




  
    
      
        
          
            ∑
            k
          
          ⁢
          
            
              ∑
              
                
                  n
                  ′
                
                ∈
                
                  
                    O
                    ′
                  
                  ⁡
                  
                    (
                    n
                    )
                  
                
              
            
            ⁢
            
              
                d
                k
              
              ·
              
                
                  x
                  _
                
                
                  n
                  ,
                  
                    n
                    ′
                  
                
                k
              
              ·
              
                r
                
                  n
                  ,
                  
                    n
                    ′
                  
                
                k
              
            
          
        
        ≤
        
          
            R
            n
          
          .
        
      
    
    
      
        (
        5
        )
      
    
  




where xn,n′k=xn,n′k/dk. If n′=tk, we set the second term in (4) to be zero as the potential at sink node tk is always zero.
In other words, node n's resource allocation decision is based on the goal to reduce, as much as possible, the total potential for all queues over all outgoing edges associated with node n. Once the optimal xn,n′k's are derived, node n then sends a flow of dk· xn,n′k across edge (n,n′) from Qk(en,n′t) to Qk(en,n′h). Notice that the resulting (normalized) queue height at Qk(en,n′h) will be qk(en,n′h)+βn,n′k xn,n′k due to the expansion factor βn,n′k; the (normalized) queue height at Qk(en,n′t) will be qk(en,n′h)− xn,n′k.
In block 208 (phase 4), absorb flow that reached its destination by draining all queues for commodity k at sink k.
Optimal resource allocation at each node: In phase 3 (block 206), for every node n∈N′, method 1 selects to process flows (among all commodities and all the outgoing edges at node n) so as to minimize the resulting potential function Φ(n) (or equivalently, maximize the potential drop at node n) subject to the resource constraint Rn. Using Lagrangian multipliers, the optimal solution for the optimization problem may be defined such that (4) and (5)




  
    satisfy
    ⁢
    
      :
    
    ⁢
    
      
    
    ⁢
    
      
        ∂
        L
      
      
        ∂
        
          
            x
            _
          
          
            n
            ,
            
              n
              ′
            
          
          k
        
      
    
  
  =
  0




for all k, n, n′, where





  L
  =
  
    
      
        ∑
        k
      
      ⁢
      
        
          ∑
          
            
              n
              ′
            
            ∈
            
              
                O
                ′
              
              ⁡
              
                (
                n
                )
              
            
          
        
        ⁢
        
          ⌊
          
            
              Φ
              ⁡
              
                (
                
                  
                    
                      
                        q
                        _
                      
                      k
                    
                    ⁡
                    
                      (
                      
                        e
                        
                          n
                          ,
                          
                            n
                            ′
                          
                        
                        t
                      
                      )
                    
                  
                  -
                  
                    
                      x
                      _
                    
                    
                      n
                      ,
                      
                        n
                        ′
                      
                    
                    k
                  
                
                )
              
            
            +
            
              Φ
              ⁡
              
                (
                
                  
                    
                      
                        q
                        _
                      
                      k
                    
                    ⁡
                    
                      (
                      
                        e
                        
                          n
                          ,
                          
                            n
                            ′
                          
                        
                        h
                      
                      )
                    
                  
                  +
                  
                    
                      β
                      
                        n
                        ,
                        
                          n
                          ′
                        
                      
                      k
                    
                    ⁢
                    
                      
                        x
                        _
                      
                      
                        n
                        ,
                        
                          n
                          ′
                        
                      
                      k
                    
                  
                
                )
              
            
          
          ⌋
        
      
    
    +
    
      s
      ⁢
      
        
          ∑
          k
        
        ⁢
        
          
            ∑
            
              
                n
                ′
              
              ∈
              
                
                  O
                  ′
                
                ⁡
                
                  (
                  n
                  )
                
              
            
          
          ⁢
          
            
              d
              k
            
            ·
            
              
                x
                _
              
              
                n
                ,
                
                  n
                  ′
                
              
              k
            
            ·
            
              r
              
                n
                ,
                
                  n
                  ′
                
              
              k
            
          
        
      
    
  




with s≧0.




  
    
      
        
          
            
              Solve
              ⁢
              
                
              
              ⁢
              
                
                  ∂
                  L
                
                
                  ∂
                  
                    
                      x
                      _
                    
                    
                      n
                      ,
                      
                        n
                        ′
                      
                    
                    k
                  
                
              
            
            =
            0
          
          ,
          
            then
            ⁢
            
              :
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              
                x
                _
              
              
                n
                ,
                
                  n
                  ′
                
              
              k
            
            =
            
              max
              ⁢
              
                {
                
                  
                    
                      
                        
                          Δ
                          k
                        
                        ⁡
                        
                          (
                          
                            e
                            
                              n
                              ,
                              
                                n
                                ′
                              
                            
                          
                          )
                        
                      
                      -
                      
                        
                          sd
                          k
                        
                        ·
                        
                          r
                          
                            n
                            ,
                            
                              n
                              ′
                            
                          
                          k
                        
                      
                    
                    
                      1
                      +
                      
                        
                          (
                          
                            β
                            
                              n
                              ,
                              
                                n
                                ′
                              
                            
                            k
                          
                          )
                        
                        2
                      
                    
                  
                  ,
                  0
                
                }
              
            
          
          ,
          
            

          
          ⁢
          
            
              with
              ⁢
              
                
              
              ⁢
              
                
                  Δ
                  k
                
                ⁡
                
                  (
                  
                    e
                    
                      n
                      ,
                      
                        n
                        ′
                      
                    
                  
                  )
                
              
            
            =
            
              
                
                  
                    q
                    _
                  
                  k
                
                ⁡
                
                  (
                  
                    e
                    
                      n
                      ,
                      
                        n
                        ′
                      
                    
                    t
                  
                  )
                
              
              -
              
                
                  β
                  
                    n
                    ,
                    
                      n
                      ′
                    
                  
                  k
                
                ⁢
                
                  
                    
                      q
                      _
                    
                    k
                  
                  ⁡
                  
                    (
                    
                      e
                      
                        n
                        ,
                        
                          n
                          ′
                        
                      
                      h
                    
                    )
                  
                
              
            
          
        
      
    
    
      
        (
        6
        )
      
    
  




The optimal value of s is the minimum s≧0 such that (5) is satisfied. That is,




  
    
      
        
          
            ∑
            k
          
          ⁢
          
            
              ∑
              
                
                  n
                  ′
                
                ∈
                
                  
                    O
                    ′
                  
                  ⁡
                  
                    (
                    n
                    )
                  
                
              
            
            ⁢
            
              
                d
                k
              
              ⁢
              
                r
                
                  n
                  ,
                  
                    n
                    ′
                  
                
                k
              
              ⁢
              max
              ⁢
              
                {
                
                  
                    
                      
                        
                          Δ
                          k
                        
                        ⁡
                        
                          (
                          
                            e
                            
                              n
                              ,
                              
                                n
                                ′
                              
                            
                          
                          )
                        
                      
                      -
                      
                        
                          sd
                          k
                        
                        ·
                        
                          r
                          
                            n
                            ,
                            
                              n
                              ′
                            
                          
                          k
                        
                      
                    
                    
                      1
                      +
                      
                        
                          (
                          
                            β
                            
                              n
                              ,
                              
                                n
                                ′
                              
                            
                            k
                          
                          )
                        
                        2
                      
                    
                  
                  ,
                  0
                
                }
              
            
          
        
        ≤
        
          
            R
            n
          
          .
        
      
    
    
      
        (
        7
        )
      
    
  




This value can be found as follows. Denote




  
    
      h
      
        n
        ,
        
          n
          ′
        
      
      k
    
    =
    
      
        
          Δ
          k
        
        ⁡
        
          (
          
            e
            
              n
              ,
              
                n
                ′
              
            
          
          )
        
      
      
        
          d
          k
        
        ⁢
        
          r
          
            n
            ,
            
              n
              ′
            
          
          k
        
      
    
  
  ,




and





  
    a
    
      n
      ,
      
        n
        ′
      
    
    k
  
  =
  
    
      
        
          (
          
            
              d
              k
            
            ⁢
            
              r
              
                n
                ,
                
                  n
                  ′
                
              
              k
            
          
          )
        
        2
      
      
        1
        +
        
          
            (
            
              β
              
                n
                ,
                
                  n
                  ′
                
              
              k
            
            )
          
          2
        
      
    
    .
  




First, sort the values of hn,n′k in decreasing order for all n′∈O′(n) and all k. Then, using the binary search to find the maximal set S+ of pairs (k,n′) such that:

i) if (k1,n1′)∈S+ and (k2,n2′)∉S+, then hn,n1′k1>hn,n2′h2 and
ii) Σ(k,n′)∈S+(hn,n′k−s)·αn,n′k≦Rn, for s=min(k,n′)∈S+hn,n′k.
Once S+ is determined, we can then compute s by setting




  s
  =
  
    max
    ⁢
    
      
        {
        
          0
          ,
          
            
              
                ⌊
                
                  
                    ∑
                    
                      
                        (
                        
                          k
                          ,
                          
                            n
                            ′
                          
                        
                        )
                      
                      ∈
                      
                        S
                        +
                      
                    
                  
                  ⁢
                  
                    
                      a
                      
                        n
                        ,
                        
                          n
                          ′
                        
                      
                      k
                    
                    ⁢
                    
                      h
                      
                        n
                        ,
                        
                          n
                          ′
                        
                      
                      k
                    
                  
                
                ⌋
              
              -
              
                R
                n
              
            
            
              
                ∑
                
                  
                    (
                    
                      k
                      ,
                      
                        n
                        ′
                      
                    
                    )
                  
                  ∈
                  
                    S
                    +
                  
                
              
              ⁢
              
                a
                
                  n
                  ,
                  
                    n
                    ′
                  
                
                k
              
            
          
        
        }
      
      .
    
  




The solution can be obtained using a reverse ‘water-filling’ method as shown in FIG. 7. The optimal s (dashed line in FIG. 7) is the line above which the total area is equal to available capacity Rn, which can be obtained by water filling into the bucket made by turning FIG. 7 upside down.
Properties of Method 1: The following theorem shows that Method 1 is stable and all queues in the system will stay bounded as desired.
Theorem 1: Consider multicommodity feasibility problem [PF]. If for demands (1+∈)dk, k=1, . . . K, there is a feasible solution that uses paths of length at most L, then for continuous flow the problem with demands dk, method 1 is stable and all queues will be bounded by

 qmax:=2√{square root over (M)}( βLν1)·C( β,L)K(1+∈)2/∈  (8)

where




  
    
      
        
          
            C
            ⁡
            
              (
              
                
                  β
                  _
                
                ,
                L
              
              )
            
          
          =
          
            
              
                1
                +
                
                  
                    β
                    _
                  
                  2
                
              
              2
            
            ·
            
              
                1
                -
                
                  
                    β
                    _
                  
                  
                    2
                    ⁢
                    L
                  
                
              
              
                1
                -
                
                  
                    β
                    _
                  
                  2
                
              
            
          
        
        ,
        
          
            and
            ⁢
            
              
            
            ⁢
            
              β
              _
            
          
          =
          
            
              max
              
                k
                ,
                n
                ,
                
                  n
                  ′
                
              
            
            ⁢
            
              
                β
                
                  n
                  ,
                  
                    n
                    ′
                  
                
                k
              
              .
            
          
        
      
    
    
      
        (
        9
        )
      
    
  




Notice that when all βn,n′k's are l's (i.e. flow conservation holds and there are no expansion effects), the above hound reduces to be the same as that in the original AL-algorithm.
Stop Criterion: Based on Theorem 1, since all queues are bounded, after running Method 1 continuously for T rounds, when T is large enough, the flow remaining in the system will satisfy:




  
    
      
        
          
            
              ∑
              n
            
            ⁢
            
              
                ∑
                
                  
                    n
                    ′
                  
                  ∈
                  
                    
                      O
                      ′
                    
                    ⁡
                    
                      (
                      n
                      )
                    
                  
                
              
              ⁢
              
                
                  
                    ⌊
                    
                      
                        
                          
                            q
                            _
                          
                          k
                        
                        ⁡
                        
                          (
                          
                            e
                            
                              n
                              ,
                              
                                n
                                ′
                              
                            
                            t
                          
                          )
                        
                      
                      +
                      
                        
                          
                            q
                            _
                          
                          k
                        
                        ⁡
                        
                          (
                          
                            e
                            
                              n
                              ,
                              
                                n
                                ′
                              
                            
                            h
                          
                          )
                        
                      
                    
                    ⌋
                  
                  ⁢
                  
                    d
                    k
                  
                
                
                  g
                  n
                  k
                
              
            
          
          ≤
        
        ∈
        
          
            d
            k
          
          ⁢
          T
        
      
    
    
      
        (
        10
        )
      
    
  




Note that from source node sk's point of view, a unit of commodity k flow at node n corresponds to 1/gnk units of flow from source sk being successfully shipped to node n due to the expansion factor gnk.
After T rounds, we will have input dkT units of commodity k into the source node sk. From (10), at most ∈dkT units of commodity k (in the view of the source node sk) remain in the system, thus (1−∈)dkT units of commodity k should have successfully reached sink tk. Hence, the long run consumption rate is at least (1−∈)dk for commodity k. (10) can be used as the stop criterion for Method 1, and the average (i.e. dividing by T) of the continuous solution gives a feasible solution to the static flow problem with demand (1−∈)dk. The following corollary is immediate.
Corollary 2: If the multicommodity problem [PF] is feasible for demands (1+∈)dk,k=1, . . . K, then there is also feasible solution (for the static problem) satisfying demands (1−∈)dk, obtained by averaging the continuous solution from Method 1.
The following two propositions give the complexity of Method 1.
Theorem 3: Each round of Method 1 takes at most O(NKM(log K+log M)) steps. Proof: Phases 1 and 2 (block 202 and 204) take KDmax steps where Dmax is the maximum node degree. Phase 4 (block 208) takes at most 2MK steps. In Phase 3 (block 206), the assignment at each node can be implemented in O(KDmax log(KDmax)) steps due to the sorting operation and the binary search process used to find S+. Since Dmax≦2M, Phase 3 needs at most O(NKM(log K+log M) steps. Therefore, each round of Method 1 takes at most O(NKM(log K+log M) steps.
Theorem 4: Method 1 terminates in at most T rounds, where T is bounded by Tmax=8M3/2( βLν1)·C( β,L)K(1+∈)2/∈2. Proof: Note that the left hand side of (10) is bounded by 2M qkdk, by setting (10) to equality, we can then obtain an upper bound for the stopping time T which gives Tmax=2M qmax/∈. The result then follows immediately based on (8).
The maximum concurrent flow problem: Use Method 1 presented above to solve the maximum concurrent multicommodity flow problem. Note that for the concurrent problem, the proportion of injected flow among multiple commodities d1:d2: . . . :dk is fixed, the problem is to find the maximum concurrent flow value δ such that input at rate {right arrow over (d)}(δ):=(δd1,δd2, . . . , δdK) is feasible.
Set the input rate to be d(δ), and vary δ until it converges to optimal δ*. The key observation is that if δ is too large, then input rate d(δ) is too much for the network and the source queues will grow without bound; on the other hand, if δ is smaller than δ*, then d(δ) should also be feasible and all queues will stay bounded based on Theorem 1. Hence, start out δ at some value that is smaller than the true maximum concurrent flow value and increase (e.g., double) it until finding that some queue exceeds the bound defined in Theorem 1. At which point ensure that the optimal δ* is within a factor of two. Then perform a bisection search to determine δ* exactly. The above procedure can be summarized as follows with reference to FIG. 8.
Method 2: (Search Algorithm for the Max Concurrent Problem): Referring to FIG. 8, in block 220, initialize δ=δo, and η>0 to be the relative error tolerance level. In block 222, run method 1 until Tmax rounds pass, or one of (normalized) queues exceeds qmax. In block 223, if Tmax rounds pass and no queue has exceeded qmax, increment (e.g., double) δ in block 225 and repeat block 222. Otherwise, go to block 224. In block 224, bisection is performed.
For the bisection step (224), in block 226, initialize δh=δ, and δ1=0. If δ>δ0, set δ1=δ/2. In block 228, set δ=(δh+δ1)/2, and run Method 1 until Tmax rounds pass, or one of the (normalized) queues exceeds qmax. In block 229, if Tmax rounds have passed, then set δ1=δ in block 230 and go to block 234. Otherwise, set δh=δ in block 232 and go to block 234. In block 234, if (δh−δ1)/δ1<η, then stop. Otherwise, go back and repeat block 228.
Maximum weighted flow problem: Consider the maximum weighted multicommodity flow problem. Assume all commodities have a maximum available input rate λ. One goal is to find the best injection rate dk for commodity k, k=1, . . . , K, such that dk≦λ and Σkwkgkdk is maximized, where gk denotes the final expansion effect for commodity k, i.e. if a unit of flow from source sk is successfully delivered, we have gk units of output at sink tk.
A distributed algorithm based on Method 1 will be presented to solve the problem. Since the optimal injection rate is not known, set dk=λ for every commodity k. Every source node sk of commodity k injects λ units of flow for commodity k into the system at each round, which is an upper bound on what the system can deliver. Clearly, if the system can handle the upper bound injection rate λ, the problem is solved. The excessive flow is controlled by queue spilling. That is, each queue sets a limit on the maximum allowed height H (to be specified later in more detail). Any flow exceeding this limit is simply deleted. The optimal weighted throughput may be achieved through deletion. Using this strategy, method 3 is presented below.
Method 3 (for the Maximum Weighted Flow Problem): Referring to FIG. 9, in block 240 (phase 1), for each commodity k, inject dk units of flow at its corresponding source sk. In block 242 (phase 2), balance all queues for commodity k at node n to equal heights. Delete any excess flow so that every queue has height no more than H. In block 244 (phase 3), for every processing node n∈N′, find flows xn,n′k, for all, so that




  
    ∑
    k
  
  ⁢
  
    
      w
      k
    
    ⁢
    
      
        ∑
        
          
            n
            ′
          
          ∈
          
            
              O
              ′
            
            ⁡
            
              (
              n
              )
            
          
        
      
      ⁢
      
        [
        
          
            Φ
            ⁡
            
              (
              
                
                  
                    q
                    _
                  
                  n
                  k
                
                -
                
                  
                    x
                    _
                  
                  
                    n
                    ,
                    
                      n
                      ′
                    
                  
                  k
                
              
              )
            
          
          +
          
            Φ
            ⁡
            
              (
              
                
                  
                    q
                    _
                  
                  
                    n
                    ′
                  
                  k
                
                +
                
                  
                    β
                    
                      n
                      ,
                      
                        n
                        ′
                      
                    
                    k
                  
                  ⁢
                  
                    
                      x
                      _
                    
                    
                      n
                      ,
                      
                        n
                        ′
                      
                    
                    k
                  
                
              
              )
            
          
        
        ]
      
    
  




is minimized under the constraint that ΣkΣn′∈O′(u)dk· xn,n′k·rn,n′k≦Rn, where xn,n′k=xn,n′k/dk.

For each commodity k, send a flow of dk· xn,n′k from Qk(n,n′) to Qk(n′,n). Note that the resulting queue height at Qk(en,n′h) will be qk(en,n′h)− xn,n′k, the queue height at Qk(en,n′h) will be qk(en,n′h)+βn,n′k xn,n′k.
In block 246 (phase 4), absorb flow that reached its destination by draining all queues for commodity k at sink k. Note that the flow weights wk are used in block 244 (phase 3) to account for the weighing factors in the objective function. The following theorem proves the convergence property and the solution quality of method 3.
Theorem 5: For any maximum weighted multicommodity flow problem with K commodities, the bounded Awerbuch-Leighton (AL) algorithm, with queues that can accommodate a flow of up to




  
    
      
        
          q
          _
        
        k
      
      ⁡
      
        (
        e
        )
      
    
    =
    
      B
      ·
      
        
          2
          ⁢
          L
        
        ɛ
      
    
  
  ,




where B is the maximum queue length derived in the previous section, and L is the longest path length in an optimal solution, delivers a solution with total return that is at most a(1+ε)-factor away from the total return of an optimal solution.

Note that Method 3 depends on the buffer size H, which controls the maximum allowed queue length in the system. Choosing the right parameter H is thus important to the performance. If H is set too low, then the algorithm may delete too much flow, and then converge to a sub-optimal solution. If H is set too high, then the method can take an unacceptably long time to converge. A buffer size of 2LBOPT*/ε where BOPT* is the maximum queue size ever reached by the optimal solution, but clearly BOPT* is not known unless one knows the optimal solution. In our experiments, we have found that setting the buffer size H=2 L max gk/ε works well.
Implementation and Numerical Results: In dynamic large scale environments, the centralized solutions are difficult to realize as the solutions may not be able to keep up with the changing environment. Furthermore, the centralized solutions may change by large amounts over a short time frame, which could lead to unstable system behavior. The methods presented herein have the advantages that they do not require global information, and can easily adapt to dynamic changes. The input and output queues, or the buffers in the presented solutions make it easy to implement in real systems. The methods could directly correspond to communication buffers at the servers.
For each iteration, a server only needs to know the buffer levels at its neighboring nodes to determine the appropriate amount of processing and transmission. As shown earlier, such a local control mechanism will lead to global optimal solutions. Dynamic changes of the system characteristics such as changes to flow expansion factors or server capacities will lead to changes to the parameters in the problem formulation. Each server can keep a running estimate of these parameters. As the changes occur, each server naturally adjusts its decisions locally. Numerical results presented below demonstrate that these procedures continue to provide high quality solutions.
Experimental results to compare the performance of the distributed algorithms with the corresponding static linear programming (LP) solutions are presented. The network topology was generated randomly. Probability-based Erdos-Renyi random graphs and random graphs generated by uniformly generating points in a unit square were explored. For Erdos-Renyi random graphs, the probability of connecting two points is set to be p≈log N/N, which ensures the connectivity of the graph for large N. Once the graph is generated, the parameters on demands d, resources R, expansion factors β, weights w and unit flow resource requirements r are then generated from independent uniform random samples. The potential function was taken to be the square of the queue heights.
Graphs of different sizes randomly generated by varying the number of commodities K, the number of nodes N and the number of edges M. The distributed algorithms were applied and the corresponding goodput (i.e. the amount of flow readied its corresponding sink successfully) was collected for each commodity and the total run time. The corresponding LP solution for the static problem was obtained using an LP solver.
Referring to FIG. 10, as an example of a random graph (generated by the second method, i.e., random graphs generated by uniformly generating points in a unit square) with 40 nodes (ovals), 4 source and sink pairs (e.g., 301 and 311, 302 and 312, 303 and 313, and 304 and 314) corresponding to a commodity problem. We will deal with 3 commodities. First, the feasibility problem associated with this graph was considered, where the desired goodput for the 3 commodities are respectively set at: d0g0=15.5, d1g1=4.5 and d2g2=11.1. The results are illustratively shown in FIG. 11.
Referring to FIGS. 11A and 11B, feasible flow problem results are shown for the random network depicted in FIG. 9. E.g., the network includes 3 commodities and 40 nodes. FIG. 11A shows total flow reaching a sink. FIG. 11B shows CPU usage as a function of network size.
FIG. 11A shows the performance of Method 1 of the feasibility problem, where the throughput achieved each round for each commodity is plotted as a function of the number of rounds. Observe that the goodput improves monotonically until it reaches the desired level, which shows that the distributed algorithm continuously improves its allocation thus pushing more and more flow in the right direction. The distributed algorithm was able to converge to the desired goodput. The convergence was very quick for commodity 0 and commodity 1, and a bit slower for commodity 2. Although it took about 6000 rounds for commodity 2 to converge to its desired throughput, in computation (CPU) time, it was less than a second, which is quite impressive.
FIG. 11B shows the CPU time it took on average for Method 1 to converge for networks for varying sizes. The three curves show respectively the CPU time it takes to reach 90% optimal, 99% optimal, and completely stable. It can be seen that at least half of the run time is cut if a 90%-optimal solution is acceptable. Observe that the larger the network, the longer it takes to converge. The curve grows super-linearly in the total number of edges of the network, which is consistent with the complexity results derived earlier that Tmax ̃M3/2. In fact, since our analytical bound on the complexity is based on worst case analysis, we find that in most of our experiments, the convergence time of the distributed algorithms is typically many orders of magnitude faster than the analytically bound. In addition, the maximum queue size in the system is also many orders of magnitude lower than the analytical bound given by EQ. (8), which indicates that the distributed method in accordance with present principles should work well in practice as the assumption on large buffer capacity is not really necessary.
The maximum concurrent flow problem is solved by using the bisection search algorithm and running Method 1 multiple times. The numerical results are the same as the results for the feasibility problem.
Referring to FIG. 12, the performance of method 3 is compared with the optimal solution obtained by the static LP for the maximum weighted multicommodity flow problem and is illustratively shown. The buffer size limits are set to, e.g., H=2 L max gk/ε. In a majority of cases, convergence time decreased significantly as compared with other naive value choices for H. FIG. 12 illustrates such an example for a 3-commodity 100-node maximum weighted flow problem. Observe that the goodput of all three commodities eventually converges to the optimal level.
The problem of how to distribute the processing of a variety of data streams over the multiple cooperative servers in a communication network has been addressed. The network is resource constrained in both computing resources at each server and in bandwidth capacity over the various communication links. A graph representation of the problem has been presented. It has been shown how to map the original problem into an equivalent multicommodity flow problem. Three different variants of objectives were considered and developed distributed methods for each case. Via both theoretical analysis and numerical experiments, these distributed methods are able to achieve an optimal solution.
Having described preferred embodiments for systems and methods for distributed resource allocation in stream processing systems (which are intended to be illustrative and not limiting), it is noted that modifications and variations can be made by persons skilled in the art in light of the above teachings. It is therefore to be understood that changes may be made in the particular embodiments disclosed which are within the scope and spirit of the invention as outlined by the appended claims. Having thus described aspects of the invention, with the details and particularity required by the patent laws, what is claimed and desired protected by Letters Patent is set forth in the appended claims.

## Claims

1. A method for resource allocation, comprising:
in a network having nodes and links, injecting components of flow for at least one commodity at a source corresponding to the at least one commodity;
at each node, balancing queue heights, associated with the at least one commodity, for queues associated with each of one or more outgoing paths associated with that node;
pushing an amount of commodity flow across a link toward a sink, including handling expansion and contraction of a quantity of the components of flow at the node, where the amount of commodity flow is constrained by a capacity constraint; and
absorbing flow that reached the sink by draining the queues.

2. The method as recited in claim 1, wherein balancing includes providing a potential function to determine adjustments to the queue heights for reducing a total potential for all queues.

3. The method as recited in claim 2, further comprising minimizing the potential function by adjusting unit-s components of flow for all queues.

4. The method as recited in claim 1, wherein balancing includes using a reverse water filling method to identify a threshold for balancing the queue heights in accordance with the capacity constraint for the node.

5. The method as recited in claim 1, further comprising determining a maximum concurrent flow rate for a plurality of commodities, by initializing a maximum concurrent flow rate variable and an error tolerance value; performing the steps as recited in claim 1 until a number of iterations exceeds T or a queue threshold is exceeded due to the maximum concurrent flow rate variable; if T iterations have been exceeded without exceeding a queue threshold, increasing the maximum concurrent flow rate variable; and bisecting the maximum concurrent flow rate variable until a criterion is met to maximize concurrent flow rate.

6. The method as recited in claim 5, wherein bisecting includes: P1 adjusting the maximum concurrent flow rate variable and repeating the step of performing.

7. The method as recited in claim 6, wherein bisecting includes:
comparing a function of the maximum concurrent flow rate variable to the error tolerance value to determine when the maximum concurrent flow rate has been determined.

8. The method as recited in claim 1, wherein balancing queue heights includes balancing all queue heights for the at least one commodity to equal heights;
and deleting any excess flow so that every queue in the node has a height of no more than a buffer size (H).

9. The method as recited in claim 1, wherein balancing all queue heights includes providing weighting factors for commodities to adjust flow to maintain the queue heights.

10. A computer program product for resource allocation comprising a non-transitory computer useable storage medium including a computer readable program, wherein the computer readable program when executed on a computer causes the computer to perform the steps of in a network having nodes and links, injecting components of flow for at least one commodity at a source corresponding to the at least one commodity;
at each node, balancing queue heights, associated-with the at least one commodity, for queues associated with each of one or more outgoing paths associated with that node;
pushing an amount of commodity flow across a link toward a sink, including handling expansion and contraction of a quantity of the components of flow at the node, where the amount of commodity flow is constrained by a capacity constraint; and
absorbing flow that reached the sink by draining the queues.

11. The non-transitory computer program product as recited in claim 10, further comprising:
determining a maximum concurrent flow rate for a plurality of commodities, by:
initializing a maximum concurrent flow rate variable and an error tolerance value;
performing the steps as recited in claim 11 until a number of iterations exceeds T or a queue threshold is exceeded due to the maximum concurrent flow rate variable;
if T iterations have been exceeded without exceeding a queue threshold, increasing the maximum concurrent flow rate variable; and
bisecting the maximum concurrent flow rate variable until a criterion is met to maximize concurrent flow rate.

12. The non-transitory computer program product as recited in claim 10, wherein balancing queue heights includes:
balancing all queue heights for the at least one commodity to equal heights; and
deleting any excess flow so that every queue in the node has a height of no more than a buffer size (H).

13. A resource allocation system, comprising:
at least one queue corresponding to one or more outgoing paths;
an input path configured to receive one or more commodities in a distributed network;
a resource allocation program configured to balance queue heights for flow unit-s components injected in the queues associated with the at least one commodity, the resource allocation program further configured to push an amount of commodity flow across a link toward at least one sink, where the amount of commodity flow is constrained by a capacity constraint,
wherein the queues permit expansion and contraction of a quantity of components of flow from the node.

14. The system as recited in claim 13, wherein the resource allocation program includes a potential function which determines adjustments to the queue heights for reducing a total potential for all queues.

15. The system as recited in claim 13, wherein the resource allocation program includes a reverse water filling method to identify a threshold for balancing the queue heights in accordance with the capacity constraint for the node.

16. The system as recited in claim 13, wherein the resource allocation program allocates resources based on one of feasibility, maximum concurrent flow and maximum weighted flow.

17. The system as recited in claim 13, wherein the system is included on a node and the node allocates resources through the node without awareness of resource allocation information of other nodes.

18. The system as recited in claim 13, wherein the system is included on a node and the node allocates resources through the node with awareness of resource allocation information of other nodes consisting only of buffer sizes of neighboring nodes.