mugurel ionut andreica, nicolae tapus politehnica university of bucharest

Constrained Content Distribution and Communication Scheduling for Several Restricted Classes of

Graphs

Mugurel Ionut Andreica, Nicolae TapusPolitehnica University of Bucharest

Computer Science Department

Constrained Content Distribution and Communication Scheduling for Several

Restricted Classes of Graphs

2

Summary• Motivation• Minimum Time Broadcast in Trees with Sending

Constraints• Minimum Time Broadcast in Trees with Sending

and Receiving Constraints• Maximum Weight Content Distribution Strategy in

Trees subject to Time Limits • Scheduling Two Communication Flows on Multiple

Disjoints Paths • Scheduling File Transfers with a Mutual Exclusion

Graph – M Intersecting Cliques• K-Interval Cover• Conclusions



3

Motivation

• efficient communication – important in many domains (scientific computing, multimedia streaming, Grid file transfers)

• efficient content distribution (broadcast) strategies + communication scheduling techniques => important for efficient communication

• optimal offline techniques– of great theoretical interest– not applicable directly in a practical setting– first step towards efficient online (real-time) techniques– useful for performance evaluation of online techniques



4

Minimum Time Broadcast in Trees with Sending

Constraints (1/6)• tree with n vertices• tree root – broadcast a piece of content to all the other

vertices• broadcast strategy

– at each time step t:• At=set of vertices which have already received the piece of content

by time t• A0={tree root}• Bt={1,2,...,n}\At

• each vertex in At can send the content to at most one of its sons• Rt=set of vertices to which the content is sent at time t from vertices

in At

• At+1=SetUnion(At, Rt)– choosing the sets Rt = broadcast strategy– T=the minimum time step when AT={1,2,...,n}– objective: minimize T

• without any constraints: “classical” problem (Slater, 1981)



5


Constraints (2/6)• sending constraints:

– for each vertex i and each time step t (0≤t<TM): sendb(i,t)=

• 1 => vertex i can’t send the content at time t (e.g. Repairs, maintenance operation) – sending is blocked

• 0 => sending is not blocked• (i) after time TM, sending is not blocked for any vertex• (ii) periodic constraints: sendb(i,t)=sendb(i,t-TM), t≥TM

• two solutions– (1) dynamic programming– (2) greedy



6

Minimum Time Broadcast in Trees with Sending Constraints

(3/6)• dynamic programming solution• Tmin(i,t)=the minimum time moment when every vertex in

vertex i’s subtree has received the content, considering that vertex i received the piece of content at time moment t

• Tmin(root,0)=the minimum broadcast time• for each (i,t)

– compute the time moments ts(i,t,1)<ts(i,t,2)<… <ts(i,t,ns(i)), s.t. sendb(i,ts(i,t,j))=0

– search for Topt (=Tmin(i,t)), s.t. all the sons of i can send the content by time Topt

– decision function (Tcand)• for each son s(i,j): tl(s(i,j),Tcand) is the largest time moment at which

vertex i can send the content to the son s(i,j), such that every vertex in vertex s(i,j)’s subtree is still able to receive the piece of content by the time moment Tcand

• sort the sons in increasing order of tl(s(i,j),Tcand) => send the content to the sons in this order

• if tl(s(i,j),Tcand)<real time moment when content is sent to s(i,j) => decision = NO; else decision=YES



7


Constraints (4/6)• dynamic programming solution (continued)• straight-forward implementation:

O(n·(n+TM)2·log(n+TM)·(log(n+TM)+log(n))) (using binary search for Topt)

• using several optimization “tricks” (increasing linear search, sliding window, double-ended queue – fully detailed in the paper): O(n·(n+TM))=O(n2+n·TM) (input size is O(n·TM))

• another version– O((n+n·TM)·log(n+TM)·log(n)) (better for small

values of TM, because the n2 factor is lost)



8


Constraints (5/6)• greedy solution• binary search for the minimum broadcast time T• decision function (Tcand)

– Tlatest(i)=the latest time moment at which vertex i can receive the piece of content such that all the vertices in vertex i’s subtree can receive the content by time Tcand

– if (i=leaf vertex) then Tlatest(i)=Tcand

– else:• sort vertex i’s sons, s.t. Tlatest(s(i,1))≥Tlatest(s(i,2))≥…

≥Tlatest(s(i,ns(i)))• the sons receive te content from vertex i in reverse sorted

order (from s(i,ns(i)) to s(i,1))• compute for each son the latest time moment tsend(i,j)

when vertex i can send the content to son s(i,j)• if all tsend(i,j)≥0 then decision=YES; else decision=NO



9


Constraints (6/6)• greedy solution (continued)• GreedyFeasibilityTest(i, Tcand):

– if (ns(i)=0) then• Tlatest(i)=Tcand

• return “passed”– else

• for j=1 to ns(i) do– ret=GreedyFeasibilityTest(s(i,j), Tcand)– if (ret=”failed”) then return “failed”

• sort the sons s.t. Tlatest(s(i,1))≥… ≥Tlatest(s(i,ns(i)))• nextson=1• for t=Tlatest(s(i,1))-1 downto 0 do

– if ((sendb(i,t)=0) and (t<Tlatest(s(i,nextson)))) then» tsend(i,nextson)=t» nextson=nextson+1» if (nextson>ns(i)) then break

• if (nextson≤ns(i)) then return “failed”• else

– Tlatest(i)=tsend(i,ns(i))– return “passed”

• O(n·log(n+TM)+n·TM) time complexity



10

Minimum Time Broadcast in Trees with Sending and Receiving Constraints

• receiving constraints– for each vertex i and time step t:

• recvb(i,t)=1 => vertex i cannot receive the content at time t (reception is blocked) ; 0 => reception not blocked

• dynamic programming– Tmin(i,t)=the minimum time moment at which all the vertices

in vertex i’s subtree can receive the content, if vertex i receives the content at time t (same as before)

– a similar approach to the previous case, except:• in order to compute the ordering of the sons => maximum

matching in a bipartite graph (son-vertices x time moments) => much higher time complexity

• the greedy algorithm can also be adjusted to solve this case



11

Maximum Weight Content Distribution Strategy in Trees

subject to Time Limits• each vertex i: weight w(i)≥0• deadline T• objective: the S set of vertices informed by time T

must have maximum total weight• dynamic programming

– Wmax(i,t)=the maximum weight of the informed vertices in vertex i’s subtree, if vertex i receives the content at time moment t

– in order to compute the son ordering (and selection): maximum weight matching in a bipartite graph (son-vertices x time moments)

• edge (s(i,j),t) with weight Wmax(s(i,j),t), if ((sendb(i,t)=0) and (recvb(s(i,j), t)=0))

• greedy solution => cannot be extended to this case



12

Scheduling Two Communication Flows on Multiple Disjoints Paths

• 2 communication flows (np1 and np2 packets)• k disjoint paths

– t(p,i)=the duration of transmitting a packet from the communication flow i on path p

• non-preemptive transfer for each packet– (1 path + 1 contiguous time interval) per packet

• objective: minimize makespan (maximum transmission completion time of a packet)

• binary search the makespan (Cmax)– feasibility test based on “knapsack”-style DP– each path p => transformed into several items

• weight q ; profit=int((Cmax-q·t(p,1))/t(p,2)) – Pmax(p, w)=the maximum profit of a subset of items whose total weight is

w, considering only the first p paths– => computes the maximum number of flow 2 packets that can be

scheduled on the k paths, after scheduling the np1 packets of the first communication flow

– time complexity: O(np12·k)

– similar to a problem discussed in my next paper (notice the differences!)



13

Scheduling File Transfers with a Mutual Exclusion Graph – M

Intersecting Cliques• n data transfers

– data transfer i• di=the duration• pi=the profit (if scheduled)

– mutual exclusion graph = M intersecting cliques (with the same common intersection)

• CI=the common intersection– vertices in CI: ESi=earliest start time; LFi=latest finish time

• Xj=Cj\CI

• deadline T• objective: schedule (non-preemptively) a maximum subset of transfer

by time T– 2 conflicting transfers cannot be scheduled during overlapping intervals

• if |CI|=k=constant => pseudo-polynomial solution (+ exponential in k) – full detailes in the paper

– state S=(t1, t2, …, t2·k) => defines k time intervals ([t1,t2], [t3,t4], ...)– Pj(i,S)=the maximum profit of a subset of the first i requests from the set Xj

(considering some arbitrary order Xj(1), Xj(2), …, Xj(i), …), scheduled outside the time intervals defined by the state S

– for k=1 => time complexity O(n·T2)



14

K-Interval Cover• n communication requests

– [tstarti, tfinishi] – disjoint time intervals– reserve the communication line at most k times, for a

minimum total duration• find k disjoint intervals s.t. [tstarti, tfinishi] is included in

their union (for all 1≤i≤n) + their union has minimum total length

• sort the intervals• compute the lengths di of the gaps between

consecutive intervals (n-1 gaps)• remove the k-1 largest gaps• answer = union (n communication intervals, (n-

1)-(k-1) remaining gaps)• easy to extend when [tstarti, tfinishi] - not disjoint



15

Conclusions

• extensions of the single port model broadcast in trees– motivated by practical applications

• maintanance operations• differing upload and download bandwidths

(sending -vs- receiving)

• communication scheduling problems on several graphs– graphs with multiple disjoint paths,

intersecting cliques, time graphs



16

Thank You !

mugurel ionut andreica, nicolae tapus politehnica university of bucharest

Documents