A Network Flow Approach in Cloud Computing

Transcription

1 1 A Network Flow Approach in Cloud Computing Soheil Feizi, Amy Zhang, Muriel Médard RLE at MIT Abstract In this paper, by using network flow principles, we propose algorithms to address various challenges in cloud computing. One of the main challenges is to consider both communication and computation constraints in the network. In the proposed network flow framework, we model the amount of computation in each node of the network as a function of its total self-loop flows. We consider two computation cost models: a linear computation cost model and a maximum computation cost model. We show that, our network flow framework can be used as a systematic technique of balancing computation loads over different nodes of the network. This network flow framework can also be used for cloud network design. A network topology is optimal for certain computations if it maximizes the total computation rate under communication/computation constraints. We propose a greedy algorithm to design a cloud network with a certain network characteristics in terms of communication and computation costs. We provide simulation results to illustrate the performance of our algorithms. I. INTRODUCTION In this paper, by using network flow principles, we address the challenge, in cloud computing, of considering jointly communication and computation limitations. Links between different nodes in the network have certain communication capacities, which we refer to as communication constraints. Moreover, performing computations in different nodes of the network requires certain computation power, which we refer to as computation constraints. In this paper, we introduce a network flow framework, capturing both of these constraints and providing optimal/suboptimal solutions for distributing computations over different nodes in the network. We also propose an algorithm to design a cloud network under given communication/computation constraints. Communication constraints have been studied extensively in information theory and communication theory literatures. A major body of work on in-network computation investigates information theoretic rate bounds, when a function of sources is desired to be computed at the receiver. Shannon considered this problem when studying the zero error capacity of noisy channels [1]. Körner introduced graph entropy [2], which is used in characterizing rate bounds in various functional compression setups (e.g, [3], [4]). Doshi et al. [5] and Feizi et al. [6] investigated graph coloring approaches to this problem. Moreover, reference [6] relaxed certain restrictive assumptions of previous works, particularly in terms of the network topology and the characteristics of the sources. Also, reference [7] computed a rate-distortion region for a functional source coding problem with side information. Another class of work on in-network computation considered the functional computation problem for specific functions. For example, reference [8] investigated computation of symmetric Boolean functions in tree networks, and references [9] and [1] studied the sum-network with three sources and three terminals. Some other references investigated the asymptotic analysis of the transmission rate in noisy broadcast networks [11], and also in random geometric graph models (e.g., [12] and [13]). Also, reference [14] investigated informationtheoretic bounds for multiround function computation in collocated networks. Network flow techniques (also known as multi-commodity methods) have been used to study multiple unicast problems (see [15] and [16]). By some modifications, reference [17] used this framework for function computation considering only communication constraints. In this paper, we propose a network flow approach to consider both communication and computation limitations in cloud computing. This framework allows us to compute optimal/suboptimal flow distributions over the network, under various computation cost models. In a general function computation framework, due to performing computations, the flow conservation constraint does not hold, for different subcomputations, in different nodes of the network. However, one can assume that, each node has a virtual self-loop of infinite capacity, and the generated flows in that node, due to computations, go in its self-loop. By using this idea, a modified flow conservation constraint can be written for the function computation setup. Further, since the total amount of flows in the self-loop of a node is proportional to the amount of computations in that node, we can model the computation cost in a node in terms of its total self-loop flows. If there is no computations in a node, the total flow in its self-loop will be zero. We consider two computation cost models: a linear computation cost (LCC) model, and a maximum computation cost (MCC) model. In the LCC model, the computation cost in each node is a linear function of the amount of computation in that node. However, under the MCC model, the computation cost over the network is a function of the maximum computation, over all nodes in the network. We propose an l p -norm relaxation of the MCC model, providing efficient algorithms to find the flow distribution over the network. Moreover, the MCC model provides a way to avoid excessive imbalance in computational effort in the cloud. Finally, by using the proposed network flow framework, we address some aspects of cloud network design. A network topology is optimal for certain computations if it maximizes the total computation rate under communication/computation constraints. Here, we propose a greedy algorithm to design a cloud network with a certain network complexity. We compare, through simulation results, our approach to a randomized design, by demonstrating the trade-off between one measure of network complexity (the number of edges in the network) and the total computation rate.

2 2 II. A NETWORK FLOW FRAMEWORK FOR FUNCTION COMPUTATION In this section, we review the network flow framework for function computation introduced in [17]. Note that, in this framework, only communication constraints are considered. In later sections, we shall modify this framework to capture computation limitations as well. The network N = (V, E) is a directed acyclic graph, where V is the set of nodes, and E is the set of edges. Each edge (u, v) has a capacity of c (u,v). N has k source nodes, {n 1,..., n k }, that have data values {X i (l)} l, where X i (l) belongs to a finite alphabet. For source node i, we use X i to represent its data. In cloud computing, source nodes can be considered as datasets. In this case, X i represents data in the dataset i. N(v) is the set of neighbors of node v in the network. The terminal node,n t, desires to compute some functions of sources data. These functions are given as computation trees. A computation tree is a graph G = (ζ, Γ), where ζ is the set of nodes, and Γ is the set of directed edges. {ζ 1,..., ζ k } represent the source nodes and ζ t is the terminal node in a computation tree. The rest are computing nodes. Elements of Γ are labeled by θ i, where {θ 1,..., θ k } are outgoing edges from source nodes, and θ t is the incoming edge to the terminal node ζ t. Some references have investigated how computation trees can be derived for a given function (for example, see [6]). Also, one function can have several computation trees. In this paper, we assume that, these computation trees are given. For a sub-computation θ Γ, tail(θ) and head(θ) represent the tail and the head nodes of that edge in the computation tree, respectively. A sub-computation θ i is a parent of a subcomputation θ if tail(θ i ) = head(θ). Children of a subcomputation θ are defined similarly. We refer to the set of parents and children of sub-computation θ as Θ p and Θ c, respectively. A given computation tree can be mapped over a network by mapping its sub-computations (edges) θ to different nodes of the network. A mapping M is feasible when all subcomputations θ can be computed by the data received from their parents in the network. Note that, one computation tree can have several feasible mappings over a network. Say M is the set of all feasible mappings of a computation tree G on the network N. By using a discrete time model, suppose r M (u, v) is the number of times that, an edge (u, v) E is used in the mapping M. For a mapping M M, let r F (M) denote the average number of function symbols computed using the mapping M per network use. Then, the computation rate R F, for a given function F, is defined as R F = M M r(m). Note that, an edge (u, v) can carry different functions of the source data from one mapping or several mappings in a timesharing scheme. In a discrete time model, the amount of flow of type θ over an edge (u, v) is the average number of symbols of a variable, that corresponds to sub-computation θ, and is denoted by f(u,v) θ. Note that, this is always less than or equal to the capacity of that edge. In a general function computation framework, due to performing computations, flow types change in nodes and (a) Fig. 1. (a) An example that shows the flow conservation constraint does not hold in the function computation setup. (b) By adding a self-loop with infinite capacity to node 3, a modified flow conservation constraint holds in this case. therefore, the flow conservation constraint does not hold, for different sub-computations, in different nodes of the network [6]. However, one can assume that, each node has a virtual self-loop of infinite capacity, and the generated flows in that node, due to computations, go in its self-loop. Therefore, the amount of flows in the self-loop of a node represent the amount of data generated at that node due to computations. To illustrate this, consider the network depicted in Figure 1-a. Suppose node 3 performs computations, and hence, changes some amount of flow of type θ to the flow of type η. Note that, the sub-computation η should be a children of the subcomputation θ in the computation tree. Therefore, f θ (1,3) + f θ (2,3) f θ (3,4). In the network of Figure 1-b, a self-loop is added to the node 3 with infinite capacity, which carries the generated flow of type η, so that, (b) f θ (1,3) + f θ (2,3) = f θ (3,4) + f η (3,3). By having this modification, the flow conservation assumption holds. This assumption is generalized in equation (1). A linear programming (LP) formulation of multi-commodity flow literature [17] can be used to compute an optimal flow distribution over the network. Algorithm 1: For a given computation tree, an optimal flow distribution over the network can be computed by maximizing the computation rate of the function.

3 3 max s.t. f η (v,v) + u N(v) f θ l u N(v) f θt (v,u) R F f θ (v,u) u N(v)\{u} { (v,v) = RF v = n l o.w. u N(v)\{v} (f(u,v) θ + f (v,u) θ ) c (u,v), (u, v) E (4) θ Γ f θ (u,v) f θ (u,u), (u, v) E, θ Γ (5), u V, θ Γ (6) where equations (1)-(6) are for each v V. Equation (1) represents flow conservation constraints. Note that, there may be more than one sub-computation η that are children of sub-computation θ, in the computation tree. Hence, the flow conservation constraint should be written for each of them. Equation (2) is the flow termination constraint in the terminal node. Equation (3) shows flow generation constraints in source nodes. Equation (4) indicates capacity constraints over edges and finally, equations (5) and (6) represent nonnegativity constraints of flows. All of these constraints are linear, and therefore, this optimization can be solved efficiently to obtain an optimal flow distribution over the network. Note that, feasible mappings leading to this obtained flow distribution can be found efficiently by using a greedy algorithm (see [17]). The network flow framework introduced in Algorithm 1 is for only one given computation tree. However, this framework can be extended for the case of having several given computation trees. For example, if two functions F 1 and F 2 are to be computed at the terminal node, the objective function will be maximizing R F1 + R F2, which is called the total computation rate, and is denoted by R tot. Flow conservation, generation and termination constraints (equations (1),(2) and (3)) can be written for each individual computation tree. However, capacity constraints of equation (4) should be considered jointly among different computations. Note that, the network flow framework of Algorithm 1 does not take into account computation costs, which is one of the main challenges in cloud computing. We shall modify this framework in later sections to address various computation cost models. To compare the performance of various distributed computation/communication algorithms, it is useful to derive upper and lower bounds on the computation rate R F by using the min-cut rate of the network: Theorem 2: Suppose the desired function require all k sources data and the min-cut rate of the network is γ. Then, γ k R F γ (7) f(u,v) θ =, (1) Proof: The lower bound corresponds to a centralized scheme, where all computations are performed in the terminal θ Γ\{θ t }, η Θ c. node. Suppose each node transmits a flow of amount γ k to the terminal node, where γ is the min-cut rate of the network. { Note that, since the min-cut rate of the network is γ, by using f θt (u,v) = RF v = n t the min-cut max-flow theorem for multicast networks [18], o.w. γ the terminal node can obtain a flow of amount k from all (2) sources. Then, the terminal node performs computations on the received sources data. Therefore, the total computation rate in this case is γ k., l {1, 2,..., k} (3) To show the upper bound, suppose all sources are connected to a virtual node by using links with infinite capacities. Also, suppose this virtual node has infinite computation power. Therefore, all computations can be performed in this virtual node. This virtual node transmits function values. In this case, since the min-cut rate of the network is γ, by using the mincut max-flow theorem, the computation rate is bounded by γ. Note that, this upper bound may not be achievable. In the next section, we introduce network flow frameworks, considering various computation cost models. III. NETWORK FLOW FRAMEWORK WITH COMPUTATION COST MODELS In this section, we consider linear and maximum computation cost models in the network flow framework of Algorithm 1 where for each case we provide efficient algorithms to compute optimal/suboptimal flow distributions over the network. A. A Linear Computation Cost Model In this section, we show how the network flow framework of Algorithm 1 can be modified to address a linear computation cost model. As described in Section II, in a general function computation framework, due to performing computations, a flow conservation constraint does not hold for different subcomputations, in different nodes of the network. However, one can assume that, each node has a virtual self-loop of infinite capacity, and the generated flows in that node, due to computations, go in the self-loop of that node (see Figure 1-b). By using this modification, flow conservation constraints of equation (1) hold in this setup. Moreover, since the total amount of flows in the self-loop of a node is proportional to the amount of computations in that node, we can model the computation cost in a node in terms of its total self-loop flows. If there is no computations in a node, the total flow in its selfloop will be zero. The key idea is to use self-loop flows to model computation costs. In this section, we consider a linear computation cost model. Definition 3: In the linear computation cost model, the computation cost in node v is proportional to the total amount of flow in its self-loop, i.e., δ v ( θ Γ f θ (v,v)), where δv is a non-negative constant.

4 4 By using the linear computation cost model, the objective function of the network flow framework of Algorithm 1 can be modified as follows: Algorithm 4: For a given computation tree, under the linear computation cost model of Definition 3, an optimal flow distribution over the network can be computed as follows: max R F ( δ v f θ ) (v,v) v V θ Γ s.t. equations (1)-(6) where δ v is a non-negative constant, and called the linear computation cost (LCC) parameter. In Section V, we shall demonstrate how this model affects the total computation rate and also the flow distribution over the network. Note that, since the considered computation cost model of Definition 3 is linear, the network flow optimization of Algorithm 1 is a linear program and can be solved efficiently. However, in some cloud computing applications, it is more desirable to have a computation cost on the maximum computation amount in different nodes of the network, which is not a linear function. We address this problem in the next section. B. A Maximum Computation Cost Model In cloud computing applications, it may be desirable to distribute computation loads over different nodes of the network in a balanced way. Therefore, it is compelling to model the computation cost as a function of the maximum amount of computation in different nodes of the network. This leads to the maximum computation cost model described as follows: Definition 5: In the maximum computation cost model, the computation cost over the network is proportional to the maximum total self-flows of nodes in the network, i.e., µ ( max v V ( θ Γ f (v,v) θ )), where µ is a non-negative constant. The network flow framework of Algorithm 1 can be modified by using this computation cost model. However, this cost function is neither linear, nor everywhere differentiable. This causes problems in designing efficient network flow algorithms. Therefore, we solve a modification of this problem, where the max-norm is replaced by an l p -norm [19]. Lemma 6: Suppose z i s are non-negative real numbers. Then, ( ) 1 i zp p i uniformly converges to max i (z i ). Proof: See [19]. Motivated by this Lemma, we propose an order p maximum cost model as follows: Definition 7: In an order p maximum cost model, the computation cost over the network is proportional to the l p -norm of total self-flows of nodes in the network, i.e., µ ( v V ( θ Γ f (v,v) θ )p) 1 p, where µ is a non-negative constant. By using the approximate maximum computation cost model, the objective function of the network flow framework of Algorithm 1 can be modified as follows: n 1 n 2 n 3 n 4 n 5 n 6 n 7 n 8 n 9 n 1 Fig. 2. The network topology considered in the linear cost computation model. All edges have capacities 1. Self Flow Nodes n t With LCC Parameter Without LCC Parameter Fig. 3. Changes in self-flows of nodes {n 7, n 8, n 9, n 1 } by imposing a linear cost computation (LCC) constraint on node n 8. Computations in the nodes of the third layer (n 9 and n 1 ) are increased under the LCC model. Algorithm 8: For a given computation tree and under the approximate maximum computation cost model of order p, an optimal flow distribution over the network can be computed as follows: max R F µ ( v V ( θ Γ s.t. equations (1)-(6) f θ (v,v) )p) 1 p where µ is a non-negative constant, and called the maximum computation cost (MCC) parameter. Note that, this network flow framework is a convex optimization and an optimal flow distribution can be computed efficiently. Moreover, this framework proposes a systematic approach to have a global computation load balance in the network, which encourages computations to be performed in a distributed way. We illustrate the performance of this framework in Section V. In the next section, we use the network flow framework for function computation to address the cloud network design problem. IV. CLOUD NETWORK DESIGN In network flow frameworks of Algorithms 1, 4 and 8, we assume that, the network topology N = (V, E) is given. One

5 5 of the challenges in cloud computing is to design a network topology to maximize the overall computation rate while satisfying certain communication/computations constraints. If the design of the cloud network is poor, network flow frameworks of Algorithms cannot lead to the most efficient flow distribution for the desired computations. A cloud network design problem can be stated as follows: Definition 9: Suppose a network N tot = (V, E tot ) is given, where V is the set of nodes in the network, including k source nodes and a terminal node, and E tot is the set of possible, capacitated, edges in the network. A set of computations is desired at the terminal node. A network topology N = (V, E) with m edges is optimal if E E tot, and the total achieved computation rate is maximized over it. Note that, we use the desired number of edges in the cloud network (m) as a measure of network complexity. For a given m, there are many network topologies, whose set of edges is a subset of E tot. A network topology is optimal for a set of computations, if the achieved total computation rate is maximized over it. In this Section, we propose an iterative greedy algorithm as a sub-optimal solution of the cloud network design problem of Definition 9. We start with a dense network, and eliminate edges by a greedy algorithm, until the number of remaining edges in the network is equal to m. To perform the edge elimination, we use the network flow framework of Algorithm 1. Note that, network flow frameworks under various computation cost models (Algorithms 4 and 8) can be used in our greedy cloud design algorithm. The key idea is that, at each iteration, an edge with the minimum total flow is eliminated. The edge elimination process is repeated until the number of remaining edges in the network is equal to m. Our greedy algorithm can be described as follows: Algorithm 1: A greedy cloud network design algorithm by using a network flow framework can be described as follows: Step (r,): Compute flow distribution f (θ,r) (i,j) for the network N r = (V, E r ) by using Algorithm 1. For the first iteration, E = E tot. Step (r,1): Choose an edge (u 1, v 1 ) with the minimum total flow: (u 1, v 1 ) = arg min (u,v) E r gij r, where gr ij = θ Γ f (θ,r) (i,j). Step (r,2): Update the set of edges: E r+1 = E r \{(u 1, v 1 )}. Step (r,3): If E r+1 = m, terminate. Else, repeat. Note that, in large networks, instead of one edge, one can eliminate at each iteration, a set of edges with the minimum total flows. In Section V, we illustrate the performance of this greedy cloud network design algorithm. V. SIMULATION RESULTS In this Section, we evaluate the performance of different proposed algorithms under various limitations by simulations. In our simulations, we consider two functions to be computed at the terminal node: F 1 = X 1 X 2 + X 3 X 4 + X 5 X 6 F 2 = X 1 X 2 X 3 + X 4 X 5 X 6. Fig. 4. model 2 n 1 n 2 n 3 n 4 n 5 n n 7 n 8 n 9 n 1 n 11 n 12 n 13 n 14 n 15 n 16 n t 5 5 The network topology considered in the maximum cost computation Self Flow With MCC Without MCC Nodes Fig. 5. Changes in self-flows over nodes in the network by imposing the maximum computation cost constraint. First, we consider a network flow framework of Algorithm 4 with a linear computation cost model. The network topology we consider is depicted in Figure 2, which has 11 nodes in three layers. All edge capacities are 1. Therefore, the mincut rate of the network is 2 (γ = 2). This min-cut contains edges (n 9, n t ) and (n 1, n t ). We assume that only F 1 is to be computed at the receiver. By using Theorem 2, R F1 γ. In this case, we show that, by using Algorithm 4 and assuming δ v = for all v V, R F1 = 2 is achievable. We assign to all computations at node n 8 a linear computation cost parameter of 1 (i.e., in Algorithm 4, assume δ n8 = 1, and δ v = for all other nodes.). Figure 3 shows the redistribution of flows in this case. When there is no computation cost at node n 8 (δ n8 = ), self-flows are distributed equally between nodes n 7 and n 8, and also between nodes n 9 and n 1. However, by making computation more expensive in node n 8 (δ n8 = 1), computation flows are redistributed, and nodes in the next layer (n 9 and n 1 ) perform further computations. Note that, in this case, no computation is performed in node n 8 and this node acts as a relay. We demonstrate the performance of the maximum computation cost model on the flow distribution for the network structure depicted in Figure 4. Here, we use an order p maximum computation cost model of Algorithm 8, where p = 15. All edges have capacity 1 except the edge (n 15, n t ), which has capacity 1. The min-cut rate of this network is

6 6 Total Computation Rate Greedy Random maximum computation cost model. For each, we provided algorithms to compute optimal/sub-optimal flow distributions over the network. Moreover, by using the proposed network flow framework, we addressed the problem of the cloud network design, where a network topology is optimal for certain computations if it maximizes the total computation rate under communication/computation limitations. We proposed a greedy algorithm to design a cloud network with a certain network complexity edges Fig. 6. Total computation rate verus the network complexity (the number of edges in the network) for greedy and random design algorithms. VII. ACKNOWLEDGMENT The authors would like to thank Dr. Michael Kilian for helpful discussions on practical issues in cloud computing applications. 11. Both functions F 1 and F 2 are desired to be computed at the terminal node. By using Theorem 2, the maximum computation rate for each function is 11, and therefore, the maximum total computation rate is 22. We use Algorithm 8 with the MCC parameter µ =.1. Figure 5 shows the change in the distribution of computations over different nodes in the network when we use the MCC model compared to the case of not having this limitation. It can be seen that, nodes in the second layer ({n 7,..., n 12 }) perform more computations under the MCC model compared to the case of not having MCC, and therefore, computation loads over different nodes of the network are more balanced in the case of having MCC than the one of not having MCC. Finally, we illustrate the performance of the proposed greedy algorithm to design a cloud network (Algorithm 1). The initial network has 6 sources, one layer of 1 nodes, and a terminal node. We assume that, E tot contains all possible edges in each layer of the network. All edges have capacities 1. The function F 1 is desired at the terminal node. Figure 6 demonstrates the total computation rate versus the network complexity (the number of edges in the network) for our greedy cloud network design algorithm and compares it to a random network design one. In a random design algorithm, at each iteration, a random edge is taken out from the network edges. To have an average performance, we repeat this algorithm 5 times, and consider its average behavior. Note that, in our greedy algorithm, at some iterations, eliminating an edge does not decrease the total computation rate. It is because of the redistribution of computation flows over other edges of the network, according to Algorithm 1. However, when this redistribution of computation flows is not possible, a decrease in the total computation rate is observed. VI. CONCLUSIONS In this paper, we proposed a network flow approach to consider both communication and computation limitations in cloud computing. This framework allows to compute optimal/suboptimal flow distributions over the network under various computation cost models. In this framework, the amount of computation in each node is modeled as a function of its total self-loop flows. We considered two computational cost models: a linear computation cost model, and a REFERENCES [1] C. E. Shannon, The zero error capacity of a noisy channel, IEEE Trans. Inf. Theory, vol. 2, no. 3, pp. 8 19, Sep [2] J. Körner, Coding of an information source having ambiguous alphabet and the entropy of graphs, 6th Prague Conference on Information Theory, 1973, pp [3] N. Alon and A. Orlitsky, Source coding and graph entropies, IEEE Trans. Inf. Theory, vol. 42, no. 5, pp , Sep [4] A. Orlitsky and J. R. Roche, Coding for computing, IEEE Trans. Inf. Theory, vol. 47, no. 3, pp , Mar. 21. [5] V. Doshi, D. Shah, M. Médard, and M. Effros, Functional compression through graph coloring, Information Theory, IEEE Transactions on, vol. 56, no. 8, pp , 21. [6] S. Feizi and M. Médard, When do only sources need to compute? on functional compression in tree networks, invited paper 29 Annual Allerton Conference on Communication, Control, and Computing, Sep. 29. [7] H. Feng, M. Effros, and S. Savari, Functional source coding for networks with receiver side information, in Proceedings of the Allerton Conference on Communication, Control, and Computing, Sep. 24, pp [8] H. Kowshik and P. R. Kumar, Optimal computation of symmetric boolean functions in tree networks, in 21 IEEE International Symposium on Information Theory, ISIT 21, TX, US, 21, pp [9] S. Shenvi and B. K. Dey, A necessary and sufficient condition for solvability of a 3s/3t sum-network, in 21 IEEE International Symposium on Information Theory, ISIT 21, TX, US, 21, pp [1] A. Ramamoorthy, Communicating the sum of sources over a network, in Information Theory, 28. ISIT 28. IEEE International Symposium on. IEEE, 28, pp [11] R. Gallager, Finding parity in a simple broadcast network, Information Theory, IEEE Transactions on, vol. 34, no. 2, pp , [12] A. Giridhar and P. Kumar, Computing and communicating functions over sensor networks, Selected Areas in Communications, IEEE Journal on, vol. 23, no. 4, pp , 25. [13] S. Kamath and D. Manjunath, On distributed function computation in structure-free random networks, in Information Theory, 28. ISIT 28. IEEE International Symposium on. IEEE, 28, pp [14] N. Ma, P. Ishwar, and P. Gupta, Information-theoretic bounds for multiround function computation in collocated networks, in Information Theory, 29. ISIT 29. IEEE International Symposium on. IEEE, 29, pp [15] R. Ahuja, T. Magnanti, and J. Orlin, Network flows: Theory, algorithms, and applications, [16] F. Shahrokhi and D. Matula, The maximum concurrent flow problem, Journal of the ACM (JACM), vol. 37, no. 2, pp , 199. [17] V. Shah, B. Dey, and D. Manjunath, Network flows for functions, in Information Theory Proceedings (ISIT), 211 IEEE International Symposium on. IEEE, 211, pp [18] R. Ahlswede, N. Cai, S.-Y. R. Li, and R. W. Yeung, Network information flow, IEEE Trans. Inf. Theory, vol. 46, pp , 2. [19] S. Deb and R. Srikant, Congestion control for fair resource allocation in networks with multicast flows, Networking, IEEE/ACM Transactions on, vol. 12, no. 2, pp , 24.