AN EFFICIENT HEURISTIC FOR BROADCASTING IN NETWORKS

1. AN EFFICIENT HEURISTIC FOR BROADCASTING IN NETWORKS Hovhannes A. Harutyunyan Bin Shao Department of Computer Science, Concordia University, Montreal, Quebec, Canada H3G 1M8.

2. WWW (WHAT WHERE WHY) • ALGORITHM TO GENERATE OPTIMAL BROADCAST TIME IN NETWORKS • EVERYWHERE • TO INCREASE EFFICIENCY AND DECREASE TIME LAG

3. INTRODUCTION • The performance of information dissemination often determines the overall efficiency of networks. • Broadcasting is a process to send a single message from one vertex to all other vertices in a network. • Broadcasting versus Gossiping.

4. TECHNICAL TERMS • V=SET OF ALL VERTICES. |V|=NUMBER OF VERTICES IN THE NETWORK. • E=SET OF ALL EDGES. • b(u,G)=MINIMUM BROADCAST TIME FOR GRAPH G.

5. EFFICIENCY • The heuristic in [2] is the best heuristic for broadcasting in practice. • This paper presents a new heuristic for broadcasting called the Tree Based Algorithm (TBA). • Time complexity of one round of TBA is O(|E|) while that of [2] is O(|V|2 . |E|).

6. TREE BASED ALGORITHM (TBA) • Basic idea of TBA is to find a matching between the set of informed and uninformed vertices in each round, and then distribute the message between them. • In TBA, procedures Calculate_weight and Calculate_match determine weights of all uninformed vertices and the matching in each round. • Given the weights of all k children of a vertex v, procedure Weight returns the weight of a vertex v in time O(k). • Flow of program: Weight MAIN PROGRAMCalculate_weightCalculate_matchMAIN PROGRAM

7. A TREE MODEL

8. PSEUDO CODE OF TBA • Heuristic TBA (tree based algorithm) Input: graph G = • (V ,E) and originator u, only u is informed. Output: broadcast • scheme and b(u, G). • 1. round = 0; /* set broadcast time 0 */ • 2. bb(round) ← all informed vertices with uninformed • neighbors; /* in round 0, only the originator is on the • bright border */ • 3. Remote ← ∅; /* queue used to calculate the weight of • each uninformed vertex */ • 4. Uninformed ← |V | - 1; /* number of uninformed vertices • */ • 5. While Uninformed = 0 • 5.1. round = round + 1; • 5.2. Perform a variant of BFS from bb(round) to uninformed • vertices, and mark any uninformed vertex • v with D(v, round); • 5.3. For any uninformed vertex v, if v has no children, • Remote ← v, v.childrenset = ∅; • 5.4. Procedure Calculate_weight; • 5.5. Procedure Calculate_match; • 5.6. bb(round) ← all informed vertices with uninformed • neighbors;

9. Procedure Calculate_weight • 1. While Remote is not empty • 1.1. v = Remote.pop(); • 1.2. if v.childrenset = ∅; • 1.3. then v.weight = 0; • 1.3. /* Refinement version */ then v.weight = 1; • 1.4. else v.weight = Procedure Weight(v.childrenset); • 1.5. For all uninformed neighbors w of v; • 1.5.1 if D(w, round) = D(v, round) − 1; • 1.5.2 then w.childrenset ← v; • 1.5.1 if D(w, round) = D(v, round)−1 and w is not • in Remote; • 1.5.4 then Remote.push(w); /* add w to the end of the • queue */ • Procedure Weight Input: v.childrenset Output: the weight • of vertex v • 0. /* Only in refinement version */ for w ∈ v.childrenset • w.weight = (w.weight)·p • q , where q is the number of parents • of w and p is a parameter. /* for each vertex w, • this calculation only be performed once in each round • although w could have more than one parent.*/

10. 1. Create Bucket[k]; /* k empty buckets, k =| v.childrenset | */ • 2. MAX(v) = max{w.weight | w ∈ v.childrenset}; • 3. for w ∈ v.childrenset • 3.1. if MAX(v) − iw.weight > MAX(v) − i − 1, • 0ik − 1; • 3.2. then Bucket[i] ← w; • 4. for 0ik − 1 • 4.1. SUM(i) = i • j=0 | Bucket(i) |; • 4.2. MIN(i) = min{w.weight | w ∈ Bucket(i)}; • 5. return max{SUM(i) + MIN(i) | 0ik − 1}; • Procedure Calculate_match • 1. list match[degree]; /* create degree lists. degree stands • for the maximum degree of all vertices in G = (V ,E) • */ • 2. for all vertices w in bb(round) • 2.1. neighbor = the number of uninformed neighbors • of w; • 2.2. match[neighbor-1].add(w); • 3. for 0idegree − 1 • 3.1. match[i].setcurr();/* set the current pointer in each • list point to the first element */

11. 4. While not all current points in lists of match[degree] • are NULL; and let the first list where current is not • NULL be match[i] • 4.1 w = match[i].getnext()) = NULL /* get the current • element, and assign it to w; current points to • the next element. */ • 4.2 v = one of the uninformed neighbors of w with • maximum weight; • 4.3 Output the broadcast scheme: w sends the message • to vertex v in the current round; • 4.4 mark v informed and Uninformed = Uninformed • - 1 ; • 4.5 for all neighbors p of vertex v such that p belongs • to a list match[j] • 4.5.1 if j = 0 then remove p from match[j]; • 4.5.2 if j > 0 then move p from match[j] to match[j- • 1]; /* if p was located before the current pointer in • match[j], then p is also located before the current • pointer in match[j-1]; and if p was located behind • the current pointer in match[j], then p is also located • behind the current pointer in match[j-1] */

12. REFINEMENT • In TBA, a vertex could be a descendent of more than one vertices. • Because of this, such vertices affected the weight calculation, and eventually the broadcast time. • A refinement scheme is used to calculate the weight of such a vertex.

13. THEORETICAL RESULTS • TBA generates optimal broadcast schemes not only for simple topologies like ring and tree, but also for grids and torus.

14. Broadcast time for a grid graph of size mxn is m+n-2 for a corner vertex. • Broadcast time for a Torus (m,n) is [m/2] + [n/2] -1

15. EXPERIMENTAL RESULTS • TBA was tested on various graphs like Star (Sd), Butterfly (BFd), HyperCube (Hd), Shuffle Exchange (SEd), deBruijn (UB(2,d)) and Cube-Connected Cycle (CCCd) of dimension d. (* DENOTES TBA FARED BETTER THAN [2]. – DENOTES [2] FARED BETTER THAN TBA) • For d<=14, TBA generated same results as in [2] except for 4 cases, 2 better and 2 worse.

16. TESTING ON SIMULATOR • To compare TBA with the algorithm from [2], three different models from ns-2 were considered: GT-ITM Pure Random [20], GT-ITM Transit-Stub (TS) [20] and Tiers[5]. • ns-2 is a widely used simulator for networking research.

17. RESULTS • The tables shown represent some of the testing results of TBA and the algorithm from [2]. RH denotes the results from [2] while TB denotes those for TBA.(*DENOTES [2] FARED BETTER THAN TBA) • Tested on about 200 different graphs for 155<=|V|<=4400. • Only one instance of [2] faring better by one point. • Overall, TBA generated the same broadcast time as in [2] or better.

21. CONCLUSION • VERY FEW INSTANCES OF [2] DOING BETTER THAN TBA. • TBA BETTERED [2] IN SEVERAL CASES. • GENERIC. • TACKLES ORIGINAL PROBLEM OF BROADCASTING MOST EFFICIENTLY.

22. QUESTIONS • MORE THAN WELCOME