peer - to - peer communication , when applied to streaming , is attractive because it enables the total bandwidth for service to scale with demand .scheduling algorithms need to be designed so that upload capacity provided by nodes can be utilized efficiently to serve the demand , and each node can download streams , providing playback continuity with small delay .the system needs to be robust enough to tolerate peer churn , link failures , and congestion .many designs have been proposed for p2p streaming .unstructured topologies with nodes constantly sampling new targets for new pieces are considered in .data dissemination algorithms based on mesh topologies are given in .in , random hamiltonian cycles are constructed and tangled and pieces are broadcasted around the union of the cycles .fixed underlying topologies are considered in and flows are scheduled between neighbors .algorithms to manage multiple distribution trees to disseminate different substreams of a video or audio are discussed in , but those papers do not concentrate on distributed algorithms .unstructured streaming systems are simple to manage and scale well , but playback continuity is sacrificed because constantly building and removing links requires prohibitive overhead .tree structures can provide good playback continuity with small startup delay , but can be difficult to manage , especially in a distributed way . in this paperwe study how to manage trees for p2p streaming as in , but with a focus on distributed algorithms .consider a complete underlying network for control information , so arbitrary node to node contact is allowed . to model the bandwidth constraint for control information, we only allow each node to randomly contact a target from other nodes periodically at a certain constant rate .this setting , which is more suitable for p2p systems , is different from settings in , which discuss how to build multicast trees satisfying certain metrics under a fixed underlying topology .most problems formulated in are shown to be np hard and approximation algorithms are designed . in this paperwe avoid np completeness with a homogeneous and complete underlying topology .the streaming network is built on top of the underlying network , through the cooperation of nodes . besides the bandwidth constraint on exchanging control information ,nodes have heterogeneous upload capacity so each of them has a maximum fan - out degree for streaming .nodes have a small buffer to store information about their parents and children in the streaming network .they can exchange messages with their parents and children , at the same time they can also exchange messages with their sampled targets at the sampling times . as in , we assume the video is cut into substreams , source coding like multiple description coding ( mdc ) is applied to provide redundancy in data . multiple diverse distribution trees , which constitute the streaming network , are constructed and managed , each for one substream .in it is mentioned that a good tree management algorithm should maintain 1 ) short trees , i.e. , trees have small depths so as to minimize the probability of disruption due to peer transience or congestion ; 2 ) tree diversity , i.e. , the set of ancestors of a node in each tree are as disjoint as possible so as to increase the effectiveness of the mdc - based distribution scheme ; 3 ) quick processing of node joins and leaves , and ; 4 ) scalability .centralized solutions in are proposed to achieve those goals . in this paper , an asynchronous distributed algorithmis designed to manage multiple trees , with the following properties :  1 .each node can receive enough substreams .depths of trees are logarithmic in the number of peers .3 .  trees are diverse and balanced .cycles are eliminated efficiently in a distributed way .convergence is fast , providing robustness to peer transience .6 .  nodes with higher upload capacity tend to be closer to the roots of the trees .heterogeneous upload capacity is supported , even in the case a few nodes with large degree act as servers and other nodes act as clients .convergence is insured even when the ratio of total demand to total upload capacity , , is one , and it converges more quickly as decreases from one .analyzing the complexity for message exchange for the algorithm is quite challenging .we show that the convergence time is stochastically tightly bounded by where is the number of nodes , both by theoretical analysis in the case of a single tree and by simulation . during a sampling interval messagesare exchanged .so we conjecture that with high probability , only messages need to be exchanged before the algorithm converges.  other related work for p2p message transmission includes , which focus on modeling the performance of file sharing networks .the paper is organized as follows .the model is introduced in . the main algorithm and the proof of convergenceare provided in .bounds on the convergence time are covered in .simulations are provided in which show that the algorithm works well even when most assumptions imposed in for theoretical tractability do not hold .consider a network containing one server and users ( nodes ) , labeled as .one video to be broadcast from the server to all nodes is cut into substreams .each substream is transmitted through a directed broadcast tree .we consider the problem of how to build broadcast trees , so as to avoid interference , achieve coverage and reduce delay .depth , .,title="fig:",width=245 ]  in this paper we consider a flow level model .let denote the set of nodes .as illustrated in , assume there are root nodes ( or roots , ) in , each of which always has an incoming link from the server , and always receives a distinct substream via such link .each root works as an `` agent '' of the server to further distribute its received substream .let denote the set of roots. for convenience , assume the root nodes are nodes 1 through , and label each substream by the label of the root receiving the stream from the server .assume nodes in can randomly contact each other and build directed links among themselves .let denote the set of all such links . through each link one and only one substream can be transmitted from the tail to the head of the link .assume that at the time a link is built , the substream to be transmitted on it is also determined .assume each link is colored by the label of the substream transmitted on it .let denote the set of all links with color for .the set of all s is a partition of ._ a node can receive substream if and only if in graph there is a directed path from root to ; and the delay of receiving substream is modeled by the number of hops of the shortest path from to . let denote the set of nodes to which there exists a path from root in .that is , is the set of nodes which can receive substream .assume that to recover the video , a node must receive at least substreams : .it is possible that , corresponding to the use of source coding .assume each node has a constraint on upload capacity ( outdegree ) : node can build at most outgoing links , whatever their colors are. contains examples of for and , where roots have outdegree one and other nodes have outdegree two . in , for each root , is a spanning tree with the minimum depth under out degree constraint , with the tree depth defined as the maximum number of hops over all root - leaf paths .five types of link updates are considered in this paper , as shown in .each link update can be executed locally because at most four nodes are involved .notice that link updates in are just combinations of building a link and removing a link .any node on the left side of a link update in can initiate that update , by exchanging messages with other nodes involved .assume each node maintains a poisson clock which ticks at rate , independently of poisson clocks of other nodes .whenever the clock of a node ticks , the node samples a target from other nodes uniformly at random , and decides whether to execute link updates in or not ._ in this paper , we assume link updates happen instantaneously , but at most one update can be executed at each sampling . _it makes the problem tractable and is also a reasonable relaxation because one link update consists of building at most two links and removing at most two links . in this paperwe normalize the time so .in , the spanning tree for each substream has depth . in the next section, we show our algorithm , under which is repeatedly updated until no more updates are possible , insures that all substreams can be broadcasted through distinct trees with depth and each node can receive enough substreams for the video . for convenience ,notations are listed :  * the _ depth to of , defined as the minimum number of hops from root to in .define if no path exists from to in ._ * the depth to buffered by , which keeps updating . * for each .* -link : an -link refers to a link colored . *-parent : is an -parent of if . * -child : is an -child of if .* -leaf : node is an -leaf if .* -internal : node is an -internal node if . * the number of outgoing -links of node .let be the total number of outgoing links of .* available : node is _available if has an incoming link and ._ * mixed node : a node is mixed if it has outgoing links with at least two colors .* mixed---node : node is a mixed---node if . * write for two sequences to mean .our main algorithm is summarized in as , which is a topology update procedure ran after nodes randomly contact each other . in the following we introduce by parts .notice that by assumption in running of is instantaneous .assume each node knows its parents , children , and colors of its incoming and outgoing links .each node buffers its depths to all roots . to begin, we assume at time  satisfies .[ a.init ]   at time , satisfies the following :  1 .each node has at most incoming links , has at most one incoming -link for each , and at most outgoing links , which implies that , 2 . is a directed tree rooted at for each .notice that 1 ) implies 2 ) in . and notice that cycles may appear in even if is a tree , as shown in .can be easily satisfied by requiring all nodes to remove extra incoming or outgoing links at time .we will show that the properties in are preserved by the update procedures we shall define . in the following the procedure for depth update is discussed first .each node buffers its depths to each root .notice denotes the depth to buffered by node .if node is root , sets to ; otherwise ,  * if has no incoming -links , sets to ; * if has incoming -links , let be the minimum depth to buffered by all -parents of , sets to .we think in .root sets its depth to as , and any other node updates its depth to as if it finds that the minimum depth to buffered by its -parents is .each node periodically runs so as to insure its buffered depths are close approximations to the real depths we will show that each node maintains just one incoming -link over all time , so a node needs to contact just one -parent when is running .we do not require nodes update depths much more frequenctly than they sample targets .assume node updates depths for three types of events :  * after builds a new incoming -link , immediately runs ( , ) .* after samples a target , runs ( , ) for all immediately .* after is sampled as a target , runs ( , ) for all immediately .thus , nodes update depths about twice as fast as their poisson clocks tick .   in this section a greedy procedure is proposed to insure that each node has at least incoming links with distinct colors .notice that nodes are randomly sampling others .assume a node runs after it samples node as a target :  * output : * return true if changes , return false otherwise .* tie broken : * arbitrarily  if has less than incoming links and there exists such that has no incoming -link but has an incoming -link ,  * * add : * if , build in , and return true ; * * insert : * if has an -child , say , remove , build in , and return true .return false .( see )    does not use depth information .it has several properties : if is valid , as nodes sample targets and run ,  1 .statements in remain valid ; 2 .  for each , is nondecreasing , but the depth of tree is also nondecreasing .3 .  for each and each node ,both and the number of incoming -links of are nondecreasing .  in the following we stateseveral additional assumptions under which running after nodes sample targets can lead all nodes to be covered by trees .first , nodes have to provide enough fan - out degrees to meet the demands of incoming links , so is assumed .[ a.link ] .second , notice that for , if at time root is not available and root does not have outgoing -links , it is not possible for any node to ever build incoming -links from .that is , over all time . to avoid that , we assume root has at least one -child at time :  [ a.root ] for each , and at time root has at least one -child ..,title="fig:",width=113 ]  third , does not generate new cycles , but it can not eliminate original cycles . as shown in , may contain cycles at time , which can not be eliminated by . in this sectionwe pause discussions on cycles by assuming is valid , in the next section we will show how cycles are eliminated .[ a.nocycle ] at time in , for any , any node with does not have incoming -links.  implies that no cycle exists in for each at time . by running no -linkswill be built beween nodes in and so no cycle ever appears .the following two indicate the convergence of running .[ lem.static ] if are valid , then at time , ( , ) returns false for all if and only if for each node , that is , if and only if each node is covered by trees .if a node has incoming links with distinct labels , returns false whichever target the node samples .so the if part follows .suppose there exists .we prove the only if part by showing that returns true when two specific nodes meet .node has fewer than incoming links .implies that each node has at most incoming links .so by .thus there exists node , say , with .a ) if has incoming links , ( , ) returns true because `` add '' can happen ; b ) if has fewer than incoming links , ( , ) returns true if because `` insert '' can happen .[ lem.cover ] under , if ( , ) runs whenever samples for any , then for all in finite time .  are valid over all time .whenever returns true , increases by one . but .follows from .can achieve coverage , but it has two main drawbacks : first , the depth of the tree for can be large ; second , it can not detect and eliminate cycles .in the next section we show how to solve these two problems by adding balance algorithms as complements .one way of decreasing the tree depth is to balance the tree .here we provide a procedure under which trees can achieve balance and cycles can be eliminated .suppose ( , ) runs whenever node samples node as a target .* output : * return true if changes , return false otherwise .  * tie broken : * arbitrarily  if there exists such that both have incoming -links ,  * * jump * : if and , remove , build in , and return true ; * * leafswap * : if is an -leaf but is not , and , remove , build in , and return true .return false .( see )    applies the information of buffered depths , which is updated periodically but may have estimation errors . analyzing under depth updating is quite challenging . _ to focus on properties of , let us temporarily assume holds .discussion under the case wihout will be covered by simulation in ._  [ a.freeerror ] , assume over all time .  for any nodes , after ( , ) runs :  1 .statements in remain valid if they are valid before running. 2 .  for any node , its number of incoming -links and number of outgoing -links both remain unchanged .3 .  under , for any node with , is nonincreasing .4 .  under, no new cycles will be generated , and cycles in can be eliminated as shown in , because for all .the following lemma shows that can return true unless all trees achieve balance .[ lem.singlebalance ] under , at time , if ( , ) returns false for all pairs of nodes , for each ,  1 .if holds , also holds , 2 .  for any two -leaves , , and 3 .each -internal node is unavailable and .\1 ) tells that for each there is at least one -leaf .thus is valid , otherwise ( , ) returns true if has incoming -links and is an -leaf .\2 ) assume node and are both -leaves and .assume is the -parent of , then .( , ) returns true .thus , depths of any two -leaves differ by at most one .\3 ) if is an -internal node , it can not be an -leaf because of 2 ) , and it can not be available otherwise ( , ) returns true where is the -leaf with the largest depth to .    intuitively running and together can achieve both coverage and balance , as well as eliminate cycles .however , balance in a tree does not garantee the tree has small depth . as shown in , if there are many nodes with a single outgoing -link , chains may appear and thereby the depth of tree can be large .fortunately , there exists ways to eliminate conditions like that , as shown in the following .nodes with a single child play an important role in increasing the depth of a tree .an unavailable node with a single -child for certain either have or is a mixed node .the case that is less interesting because most nodes can be required to provide at least two outdegrees , especially when the streaming rate of a substream is small comparing to the upload capacity .suppose holds for simplicity .[ a.2 ] for all .notice that in existence of nodes with outdegree zero is allowed .gets rid of the case that many nodes have outdegree one .reducing the number of mixed nodes can lower the tree depths . in this sectionwe provide under which the number of mixed nodes can be greatly reduced . for any pair of nodes , suppose ( , ) runs when samples as a target .* output : * return true if changes , return false otherwise .* tie broken : * arbitrarily .if there exist such that has an -child say , has an -parent say , and   * mixswap * : if and either of the two is true :  * or , * , , , ( note are ids in \{1, ... n}. )  then remove , build in , build in , and return true .otherwise return false .( see )   and switch their parents if one can decrease its depth while the other one s depth does not increase , or depths are unchanged but lower - id parents can get lower - color links.,title="fig:",width=207 ]  ( , ) returns true if after `` mixswap '' , between and one child of , one can decrease its depth while the other one s depth does not increase , or depths are unchanged but parents with lower ids can get outgoing links with lower colors .we break the tie by assuming parents with lower ids have a preference on links with lower colors , so as to eliminate the case that there are many mixed nodes with exactly the same depths in multiple trees .  under , for any pair of nodes , after ( , )runs ,  1 .statements in remain valid if they are valid before running is nonincreasing for any node , 3 .no new cycle is generated .moreover , the following lemma indicates that can return true unless depth vectors of mixed nodes form a strict chain :  [ lem.mix ] under , if ( , ) returns false for all pairs of nodes , for any and any two mixed---nodes , either or .the lemma follows by noticing that if are both mixed---nodes , `` mixswap '' can happen when either a child of contacts or a child of contacts , unless and are in a strict order .still does not guarantee that the number of mixed nodes is small . as shown in, mixed nodes can form a long chain where the conclusion in still holds .however , the appearances of the structure in are quite rare because random sampling is assumed . and intuitively it becomes rarer as increases . in practice we may safely ignore it , but here for completeness of analysis , we eliminate the possibility of a long chain as in by assuming holds. we will show later by simulation that ignoring does not harm performance .[ a.hat ] at time , there exists such that for each , there are at least -leaves in , where .says that initially in any tree the subtree of nodes with depth bounded by has at least leaves. intuitively suggests there is something analogous to a shower head , which provides enough branches near the top of each tree .the value in can be as small as , or even if the root or its children have large outdegrees .we have under .  [ lem.balance ] under ,if ( , ) and ( , ) both return false for all , then for each the depth of each tree is less than or equal to , where is defined in .suppose the depth of tree is .tells that for each and for each , there are at most one mixed---nodes whose depth to is .so there are at most mixed nodes which have -child and whose depth to is .tells that all -internal nodes must have at least children because they are unavailable and because holds .thus , for each , in the set of nodes whose depth to is , at most of them can have a single -child , while each of the other nodes has at least -children because they are unavailable non - mixed -internal nodes .notice that there are at least nodes whose depth to is .thus , the number of nodes whose depth to is in  ] is identical for processes or ._ in the following , our discussion are on process . for simplicity, we apply the same notations for as for . let .notice that the number of available nodes with depths is larger or equal to : consider each node labels its outgoing degrees and marks the first two degrees red .each node has at least red degrees but there are only nodes to serve .so there are at most nodes whose red degrees are both taken .the number of nodes with depths is larger or equal to .thus , if , the transition rate for to jump is lower bounded by   there exists a process in on an extended probability space such that each coordinate of has jumps of size one and jump rate for is . notice that simultaneous jumps of different coordinates of are allowed .let .initially we have .process and can be coupled so that with probability one for all .that is because if then jump rate of is larger or equal to jump rate of for all such that .so the jumps of can be obtained by generally thinning the jumps of , and adding more jumps to s with .  by inductionit is easy to show that with probability one for all , because jump rate of is zero if .moreover ,  ] .define .notice that , apply markov s inequality and , = p[z_{l_\alpha}(t ) \leq ( 1-\alpha)n-1 ] \\ & \leq & p[{\tilde{z}}_{l_\alpha}(t ) \leq 2^{l_\alpha+1}-2 ] = p[\delta(t ) \geq 1 ] \\ & \leq & e[\delta(t ) ] \leq 2^{l_\alpha+1}-1 - y_{l_\alpha}(t)\\ & \leq & 2^{l_\alpha+1 } p[pois(\alpha t/2)\leq l_{\alpha}-1].\end{aligned}\ ] ] the lemma follows .[ lem.diff ] let to be a motion trajectory defined by the following : where is a constant , then \right\ } -1.\ ] ]  let / 2^{i+1} ] if , and , we have \leq 2\exp\left\ { r(1+ln 2 - { t\over r } + ln{t\over r } ) \right\},\ ] ] where .notice that , so \leq 2e^ { -\epsilon } .\ ] ] consider : \geq 1 - \alpha n e^{-(1 - 2\alpha)t/2 } \geq 1 -  ( n+1 ) e^{-(1 - 2\alpha)t/2}.\ ] ] and so \leq e^{-\epsilon}.\ ] ] choose , which minimizes , we get \leq 3e^{-\epsilon}.\ ] ]we show that works pretty well under , without .let each node sample targets randomly with rate and run. is not invoked so depths update distributedly .notice that runs instantaneously in simulations . in each experimentbelow , we set fixed ; at time , we first set to be empty , then let each root build an -child which is randomly selected from .so at time  contains links and both hold .we let hold too .  because holds , during each simulation below for each is always a tree .tree is given by .say that a node is _ covered by tree _ if , and say that a node is _ fully covered _ if it is covered by at least trees .  in experiments below, the parameters chosen include and the degree vector . for each selection of parameters , we repeat running the experiment times , with each experiment running for time units and with system states recorded in the same time units .metrics considered include the fraction of nodes fully covered and the maximum tree depth .   in this series of experiments , we let each root have degree : , and let each non - root node have degree : , .the capacity is tight because the equality in is achieved : .keep so holds . after repeating an experiment for times , for ,we record metrics of the worst experiment at each time . notice that each line with legend `` worst case '' correponds to the case , which means that there is no experiment performing worse than the line at any time .( ) .point on a line legended means only in of experimentsthe corresponding metric at time is worse than .,title="fig:",width=162 ]  0.22 .point on a line legended means only in of experimentsthe corresponding metric at time is worse than .,title="fig:",width=162 ]  for example , in we set .a point in on the line with legend `` '' means that in of repeated experiments , the fraction of nodes fully covered at time is no larger than ; a point in on the line with legend `` '' means that in of repeated experiments , the max tree depth at time is no less than .  shows what a specific sample path looks like under . in, we can see that the fraction of nodes fully covered increases almost exponentially from to , over nodes are fully covered by time under experiments .that is because nodes can gradually increase the number of trees covering them until they get fully covered , as they meet other fully covered nodes ._ it appears that the fraction of nodes is almost nondecreasing over all time , which validates that cycles generated are rare and are quickly eliminated ._ as indicated in , the maximum tree depth increases linearly in the beginning , then decreases almost exponentially , and finally converges to below . at time , in repeated experiments max tree depths are below .the rate of convergence follows , though is for the case of one tree .notice that not only in , but also in all our simulations below , the `` worst case '' lines are quite close to the `` 1% '' lines , but the latters are much more smooth than the former . _ in the following , we apply `` 1% '' lines instead of `` worst case '' lines to describe performance . _  0.22  cumulative lines when varies ., title="fig:",width=162 ]  0.22  cumulative lines when varies ., title="fig:",width=162 ]  in we test different s so as to make sure convergence follows in other cases .notice that typically in practice is below .set with varying in .we expect to observe similar images as in , with longer convergence time as increases because each node has to get covered by more trees . for each , we draw the worst case line in . as expected , for each both the fraction of nodes fully covered andthe max tree depth converge , as in . in , lines shift right almost linearly with a slow rate as increases . with , over nodes are fully covered by time . in, lines shift both downwards and right , and converge to lower values as increases .because balanced trees have smaller depth if nodes have larger degree : with , the line converges to in .whatever is , the max tree depth is below by time .0.22  cumulative lines when varies and .,title="fig:",width=162 ]  0.22  cumulative lines when varies and .,title="fig:",width=162 ]  in , we test the case under source coding by drawing the worst case lines when and be in , that is , there are more trees than nodes need .notice that the capacity is still tight . in , lines shift left as increases , showing that source coding tends to decrease the convergence time for coverage . in, limits slightly increase as increases . because when is larger there are more types of mixed nodes , which may have single children in a tree and thereby increase the depth .that condition is also implied by , where the value is considered to be of .thus , source coding creates a tradeoff between the tree depth limit and the convergence time of coverage . intuitively and as shown in , the increasing of depth limit is of which is small , so it is worth trying source coding to get a faster convergence .  for all simulations above, we test cases where the capacity is tight , which illustrates and supports that convergence is exponential . one common feature of curves in is that long tails exist .for example , in , it takes quite long for curves to arrive at . that is because near the end of the process only a few nodes are available and a few others are not fully covered , and it takes long for these nodes to meet each other by random sampling .long tails can be eliminated by broadcasting or adding more capacity .broadcasting is not discussed in this paper , in the following we show experiments where extra capacity exists .   0.22  cumulative , and varies.,title="fig:",width=162 ]  0.22  cumulative , and varies.,title="fig:",width=162 ]  we set the total number of degrees , with a new parameter . to achieve that, we first let each node have degree , then add degrees , one by one , to nodes selected uniformly at random . in, we set , and let increase . in , we can see that adding just extra capacity can greatly shorten the tail : all nodes are fully covered by time as shown by the line .the larger is , the shorter the tail is . when , all nodes get fully covered by time .in , as increases , curves converge faster and limits also decrease .   0.22  cumulative . , server nodes with degree , degrees added to server nodes randomly.,title="fig:",width=162 ]  0.22  cumulative . , server nodes with degree , degrees added to server nodes randomly.,title="fig:",width=162 ]   +  0.22  cumulative . , server nodes with degree , degrees added to server nodes randomly.,title="fig:",width=162 ]  0.22  cumulative . , server nodes with degree , degrees added to server nodes randomly.,title="fig:",width=162 ]  0.22  cumulative . , server nodes with degree .,title="fig:",width=162 ]  0.22  cumulative . , server nodes with degree .,title="fig:",width=162 ]  in this section , we show that works well under the server - client case , where a portion of nodes are server nodes with high degrees and other nodes are client nodes with zero degrees .the algorithm favors nodes with higher degree ; they tend to get smaller depths than nodes with lower degrees .we expect to observe similar images as in .notice that the convergence times will increase because it takes more time for nodes to meet server nodes under uniform random sampling .that problem can be solved by adding mechanisms to help nodes find server nodes . in this paper , we stay focused on the uniform sampling assumption despite the small increase in convergence time .  in , we let server nodes ( include roots ) have degree and all other nodes have degree , then add degrees one by one to server nodes randomly .as expected , in , lines shift right as increase because there are less server nodes , but still increases exponentially from to .in , max tree depth decreases greatly as increase from to , and further decreases as increase . in, is fixed at with increases , which shows long tails get eliminated like that in .  in, we let server nodes ( include roots ) have degree and all other nodes have degree .we set , let increase , and draw the line at for comparison .notice that lines at in are exactly the same . as increases ,there are more server nodes so lines shift left quickly in , and max tree depth decreases quickly in . when , lines in are close to lines in . as increases , in lines shift left but in they do not .that suggests that performance is sensitive to the number of server nodes instead of the degree distribution among server nodes .above all , our simulations validate by showing that fraction of nodes fully covered increases from to , and the maximum tree depth decreases to its limit , almost exponentially , under tight or un - tight capacity constraint , homogeneous or heterogeneous capacity distribution , when hold .the simulations suggest that cycles are eliminated quickly because the fraction of nodes covered is almost increasing over all time ; long tails can be eliminated by adding extra capacity ; and the algorithm favors nodes with higher degree so it works well under the server - client case too .convergence times increase with either increasing or decreasing the chance for nodes to meet server nodes .when parameters change , curves shift with shapes staying similar , revealing robustness of the algorithm .in this paper a distributed algorithm to manage multiple trees for streaming is proposed .the algorithm can achieve coverage , balance , and small delay in a short time .the algorithm works on a complete underlying graph assuming random sampling among peers is enabled .future work may include extending the algorithm for given incomplete underlying topologies .this work was supported by the national science foundation under grant nsf ccf 10 - 16959 .w. zhang , q. zheng , h. li , and f. tian , `` an overlay multicast protocol for live streaming and delay - guaranteed interactive media , '' _ journal of network and computer applications _ , vol .35 , no . 1 ,pp . 2028 , 2012 .

Abstract: this paper presents an asynchronous distributed algorithm to manage multiple trees for peer - to - peer streaming in a flow level model . it is assumed that videos are cut into substreams , with or without source coding , to be distributed to all nodes . the algorithm guarantees that each node receives sufficiently many substreams within delay logarithmic in the number of peers . the algorithm works by constantly updating the topology so that each substream is distributed through trees to as many nodes as possible without interference . competition among trees for limited upload capacity is managed so that both coverage and balance are achieved . the algorithm is robust in that it efficiently eliminates cycles and maintains tree structures in a distributed way . the algorithm favors nodes with higher degree , so it not only works for live streaming and video on demand , but also in the case a few nodes with large degree act as servers and other nodes act as clients .  a proof of convergence of the algorithm is given assuming instantaneous update of depth information , and for the case of a single tree it is shown that the convergence time is stochastically tightly bounded by a small constant times the log of the number of nodes . these theoretical results are complemented by simulations showing that the algorithm works well even when most assumptions for the theoretical tractability do not hold .