Low-Stretch Spanning Tree on Benchmark Circuits

Transcription

1 Low-Stretch Spanning Tree on Benchmark Circuits Yujie An and Igor Markov Department of Electrical Engineering and Computer Science University of Michigan July 8, 2013 Abstract We show the testing results of Kruskal, Prim-Dijkstra for finding a low-stretch spanning tree for both unweighted graphs and weighted graphs transformed from benchmark circuits [1]. On unweighted graph, our implementation can get an average stretch of about 7 for all benchmark circuits. Kruskal s algorithm gives good edge selection for finding short stretch edges, but does not work well for other large stretch edges. Prim-Dijkstra algorithm works well on Dijkstra s part, but not well on Prim s part. The shortest path algorithm may not give minimum spanning tree, but it can keep the average stretch of off-tree edges very small. On random weighted graph, in which all edges are given a random weight, our implementation can get an average stretch of about 6.5 for all benchmark circuits. This result is even better than unweighted graphs. Prim-Dijkstra algorithm works better than Kruskal s algorithm, and this is mostly due to Dijkstra s shortest path. What s more, a ratio for about can make Prim-Dijkstra algorithm works even better. The low-stretch spanning tree we get is a shortest path tree, with a slightly variation to minimum spanning tree. 1 Introduction Let G = (V, E, d) be a graph (unweighted or weighted), where d : E R + assigns a positive length to each edge (d = 1 for unweighted graph). Given a graph G of V, the distance in G between a pair of vertices u, v V, denoted by dist G (u, v), is defined as the sum of the lengths of of the edges on the shortest path in G between u and v. Given a spanning tree T, we can then define the stretch of an edge (u, v) E to be [2] stretch T (u, v) = dist T (u, v). d(u, v) Note that this definition of the stretch differs slightly from the best-known one, as used in [3], and [2] discusses their difference. The average stretch over all edges of E is defined to be [3] avg-stretch T (E) = 1 E Moreover, we define the eccentricity ɛ(v) to be (u,v) E ɛ(v) = max u V {dist G(u, v)}, stretch T (u, v). 1 which can be seen as the distance from that vertex to the farthest vertex. The diameter of a graph is the maximum eccentricity of any vertex in the graph, and a central point is the mid vertex (or one of the mid vertices) on the diameter. anyujie@umich.edu, imarkov@eecs.umich.edu 1 This may appear as ave-stretch later, which is used in [3]. 1

2 2 Background We want to find a low-stretch spanning tree for benchmark circuits, and make sure that the average stretch of the tree is actually low enough. Thus, both tree finding and stretch calculating algorithms are needed. 2.1 Finding a Low-Stretch Spanning Tree We construct our low-stretch spanning tree by Kruskal and Prim-Dijkstra algorithm. Kruskal s algorithm [4] is one of the most well-known algorithms that can find a minimum spanning tree of a graph. Prim-Dijkstra algorithm is a mix of Prim s algorithm [5] and Dijkstra s algorithm [6], with a real number weight w from 0 to 1, using w d[v, s]+(1 w) d[v, T ] for next point selection, instead of d[v, s] in Dijkstra s algorithm and d[v, T ] in Prim s algorithm. Using weighted sum of distances as priority can take advantage of both Dijkstra s and Prim s algorithm, and are more likely to find a lower average stretch tree. 2.2 Calculating Average Stretch We only need to calculate the total stretch. Given a tree, we randomly select a root r, and construct a tree structure according to r. For every edge in the original graph, the stretch for that edge is stretch T (u, v) = d T (u, r) + d T (v, r) 2 d T (LCA(u, v), r), d(u, v) in which LCA represents Lowest Common Ancestor [7]. Since all d T (x, r) can be pre-calculated in O(n), the problem now is to find the LCA(a, b) as fast as possible. There are several well-known ways to find the LCA in O(n log n) O(log n) or O(n) O(1) times, where first O represents pre-calculation complexity, and second O represents one query complexity. For the O(n log n) O(log n) algorithm, it uses dynamic programming, which is very similar to sparse table method of Range Minimum Query (RMQ) [8] problem. For each vertex x, T [x] represent the father of x in the tree, and we don t care the father of root, which would never be used for querying. In this way, we pre-calculate P [i][j] as P [i][j] = { T [i], j = 0, P [P [i][j 1]][j 1], j > 0. We then define L[x] be the level of vertex x in the tree. We can see that if two vertices a, b are in the same level, we can calculate LCA(a, b) by binary search. Therefore, we first make two queried vertices into the same level. Without losing generality, we assume that L[a] < L[b], we can use binary search for finding the ancestor of b situated on the same level of a. After that, for every power j of 2 (between log(l[a]) and 0, in descing order), if P [a][j] P [b][j] then we know that LCA(a, b) is on a higher level and we will continue searching for LCA(a = P [a][j], b = P [b][j]). At the, both a and b will have the same father, so return T [a]. More details and implementations can be found at [9]. For the O(n) O(1) algorithm, it first changes LCA to restricted RMQ in O(n), then solve each query in restricted RMQ in O(1). More details can be found at [9]. However, this algorithm is not as fast as we thought it would be, because it probably has a pretty big constant when queried. As we can see, for each query, it needs at most four random accesses to two huge arrays. This means if our log n factor is much smaller than 4, O(log n) query would work better. We will not go into details, but our implementation shows that O(n log n) O(log n) query works better, and we will stick to this algorithm in future. 3 Unweighted Graph Analysis In this section, we will show our results in unweighted graphs generated by benchmark circuits [1]. All the resulting data, including average stretch, longest stretch, diameter, stretch distribution, will 2

3 be shown. 3.1 Unweighted Graph Parser We use a very simple parser to get an unweighted graph from benchmarks. For all nodes that already exist, we give it a corresponding vertex in our unweighted graph. For all edges in nets, if the edge is a hyperedge, we give a new vertex representing the center of the hyperedge, and give an edge from this center to each vertex on this hyperedge; if the edge is not a hyperedge, we connect them. Unfortunately, the graph parsed in this way is not connected, and it always contains a huge connected component, which contains almost 99% of all vertices, and lots of small components. To simplify the problem, we filter out all small components, and leave only the largest connected component. 3.2 Original Graph Information Table 1 shows the parsed input graph size of benchmark circuits [1]. (* is the data after filtering.) Table 1: Benchmark circuit input graph size Benchmark No. Num. of Vertices Num. of Edges Num. of Vertices* Num. of Edges* Unweighted Central Vertex Heuristics All of our algorithms use a central vertex heuristic. This is a heuristic that can significantly decrease the average stretch of the spanning tree generated by Kruskal s algorithm, and slightly optimize the result of Prim-Dijkstra algorithm. To apply this heuristic, we need to detect the radius of the graph first. We define radius by first finding it. Starting at a random vertex, by using breath first search (BFS), we can find the furthest vertex from it. Save this point and the length of this path. Note that when meeting a tie, randomly select one vertex for the next start. Different selection would sometimes affect the result. After that, we keep doing new BFS start from the vertex obtained from last BFS, until the furthest point s distance does not change any more. We define radius be a tuple of (s, t, d), where s is the start point, t is the point, and d is the shortest distance between them. Finally, the last BFS would give us a radius with d be about half of the length of real diameter. After finding the radius of the graph, we actually have two ways to define our heuristic number. 1) We perform another two BFS from both s and t of the radius, and give a heuristic number to all vertices in the graph. The heuristic number is the larger one of the two distances from each s of radius. 2) We perform only one BFS from either s or t of the radius, and give a heuristic number of abs(d k), where d is in radius, k is the distance from that vertex to the start point now, and abs is the absolute value. Finally, we choose the vertex with the smallest heuristic number to be the start vertex of Prim- Dijkstra algorithm, and sort all edges according to the sum of heuristic numbers of two vertices on the edge, from small to large, for Kruskal s algorithm. In fact, heuristic 1 works better than heuristic 2 in practice, and we will show the result later. 3

4 3.4 Kruskal s algorithm In this section, we will give our implementation of Kruskal s algorithm and its results Pseudocode for Kruskal s algorithm Data: Graph G Result: a spanning tree of G sort-edges-by-heuristic A for v V do makeset(v) for e E do if set(v1) set(v2) then A A + make-edge(v1, v2) union(v1, v2) return A Algorithm 1: Kruskal s algorithm Runtime results Testing OS: Red Hat Enterprise Linux Workstation release 6.4. CPU model: Intel(R) Xeon(R) CPU E GHz. CPU MHz: Cache Size: 8 MB. CPU Number: 4. Table 2 shows a onetime result of Kruskal s algorithm using heuristic No.1. (Note: R represents runtime, and it s in seconds. R1 is runtime for finding a central vertex, R2 is runtime for Kruskal s algorithm and R3 is runtime for calculating average stretch.) Table 2: Result of Kruskal s algorithm unweighted version No.1 Benchmark No. Avg-Stretch Longest Stretch Diameter R1 R2 R Table 3 shows a onetime result of Kruskal s algorithm using heuristic No.2. 4

5 Table 3: Result of Kruskal s algorithm unweighted version No.2 Benchmark No. Avg-Stretch Longest Stretch Diameter R1 R2 R We can see that heuristic No.2 generally does not work well for Kruskal s algorithm, but it can sometime work better, as in benchmark No.5. Since it runs fast, it is probably a good idea to run both heuristics and find the better result. We will go into more details in Prim-Dijkstra algorithm, since heuristic No.2 works much better there Off-tree edges stretch distribution Kruskal In order to know whether we can add some off-tree edges to significantly reduce the average stretch, we get the following figures. Figure 1 gives off-tree edges stretch distribution for benchmark 1.. (All following data are obtained using heuristic No.1.) Figure 1: Stretch distribution for benchmark 1 unweighted version Kruskal It seems that the distribution is reasonable, most of the stretches are close to the average, and there is no very long stretch. To verify this, we can see another Figure 2 for benchmark Figure 2: Stretch distribution for benchmark 7 unweighted version Kruskal 5

6 According to this graph, we know that our central vertex heuristic works pretty well for Kruskal s algorithm to make most stretches small and close to the average. However, the longest stretches are very long, which means that simple sort for edges by the central vertex heuristic would result in not considering some edges, so that their stretches would be significantly long. We will compare this with Prim-Dijkstra later. 3.5 Prim-Dijkstra algorithm In this section, we will give our implementation of Prim-Dijkstra algorithm and its results Pseudocode for Prim-Dijkstra algorithm Here is the pseudocode for our Prim-Dijkstra algorithm. Note that when calculating heuristicdistance d, we use the weighted sum of the heuristic-distance from that vertex to source and to tree. The sum should be d[v] = d[current] w + dist[current, v] (1 w), since in this way, the source distance can be reduced by a factor of w, and after the reduction its significance can be compared with tree distance. If we purely use distance d and calculate heuristic-distance h = d[current] w + dist[current, v] (1 w), then after a few iteration, d[current] would grow so big that dist[current, v] would have very tiny effect on h. Data: Graph G, Ratio w Result: a spanning tree of G source Central-Finding-Heuristic(G) T d[1... V ] = father[1... V ] = 1 d[source] = 0 for v / T do current vertex with minimum d if current does not exist then break T T + current for all neighbor v of current do if d[v] > d[current] w + dist[current, v] (1 w) then d[v] = d[current] w + dist[current, v] (1 w) f ather[v] = current A for v V do if father[v] -1 then A make-edge(v, father[v]) return A Algorithm 2: Prim-Dijkstra algorithm Runtime results Table 4 shows the runtime result for Prim-Dijkstra algorithm, with w = 1 and heuristic No.1. (Note: same as before, R represents runtime, and it s in seconds. R1 is runtime for finding a central vertex, R2 is runtime for Prim-Dijkstra algorithm and R3 is runtime for calculating average stretch.) 6

7 Table 4: Result of Prim-Dijkstra algorithm unweighted version with w = 1 No.1 Benchmark No. Avg-Stretch Longest Stretch Diameter R1 R2 R Table 5 shows the runtime result for heuristic No.2. Table 5: Result of Prim-Dijkstra algorithm unweighted version with w = 1 No.2 Benchmark No. Avg-Stretch Longest Stretch Diameter R1 R2 R As we can see, for benchmark 4, 7, 16, heuristic No.2 works better than heuristic No.1, and it almost significantly reduce the average stretch of benchmark 7. Therefore, it is a good idea to run both heuristics and return the better result Different weights effect on average stretch In order to find the best ratio w, we tested 101 different w from 0 to 1, 0.01 scaled. Figure 3 shows the ratio plot for benchmark 1 generated by our Prim-Dijkstra algorithm. As we can see, the method Figure 3: Ratio plot for benchmark 1 unweighted version 7

8 does not work well on unweighted graph. The reason is actually quite simple: on unweighted graph, all weights can be seen as 1, and in this way, Prim s algorithm is actually pure random. The result is not terribly bad because we have the central vertex heuristic, and if we delete the heuristic and start from a random point, the average stretch would be extremely long. We will go back to this in detail in weighted graphs Off-tree edges stretch distribution Prim-Dijkstra Same reason as for Kruskal, we calculate this stretch distribution (Figure 4) for Prim-Dijkstra algorithm. (Using heuristic No.1.) Figure 4: Stretch distribution for benchmark 1 unweighted version Prim-Dijkstra It seems that the distribution is quite even, and there is no off-tree edges that have a significant large stretch. Figure 5 is another plot for benchmark 7, the largest one of all benchmarks Figure 5: Stretch distribution for benchmark 7 unweighted version Prim-Dijkstra It seems that there are some edges that have pretty large stretch, and it is intuitive to guess that these edges are connecting two parts far from the center, and also far from each other. We believe that this attribute would become more obvious when dealing with weighted graphs, and we would then try to figure out whether we could add in some off-tree edges so that we can significantly reduce the average stretch. Comparing to Kruskal s result, Prim-Dijkstra algorithm is actually much better. For the lowstretch edges whose stretches are less than 17.5, the total number is generally the same. However, Prim-Dijkstra works better for larger stretch. This suggests that we should need something that is similar to the shortest path when finding a low-stretch spanning tree, not only minimun spanning tree. 8

9 4 Weighted Graph Analysis Random Length In this section, we will show our results in weighted graphs generated by benchmark circuits [1]. All edges lengths are generated by normal distribution generator. 4.1 Random Length Weighted Graph Parser This parser is almost exactly the same as our unweighted graph parser, except that it gives a random length to each edge. The random numbers are generated by normal distribution, with mean µ = 100, and standard deviation σ = 20. Also, we check whether it would generate some negative numbers, though with extremely small probability. If this happens, we set the length to another random number from the distribution. There is one more thing that needs to be mentioned. Our parser works only one time, which means that the input data for the following algorithms keep the same all the time, without randomness. 4.2 Original Graph Information Table 6 shows the parsed input graph information after filtering. Table 6: Benchmark circuit input graph information random length Benchmark Num. of Vertices Num. of Edges Average Length Longest Edge Shortest Edge Weighted Central Vertex Heuristics The central vertex heuristic becomes more complex in weighted graphs. We defined the unweighted central vertex heuristic number be the number we calculated by our previous central vertex heuristics. We now define the weighted central vertex heuristic number as follows. We keep the definition of radius the same as before. For weighted graphs, instead of BFS, we use Dijkstra s algorithm for each search, and finish until the longest distance does not change any more. This would give us a radius. After finding the radius, we still have two ways to define our heuristic number. 1) We perform another two Dijkstra s algorithm from both s and t of the radius, and give a heuristic number to all vertices in the graph. The heuristic number is the larger one of the two distances from each s of radius. 2) We perform only one Dijkstra s algorithm from either s or t of the radius, and give a heuristic number of abs(d k), where d is in radius, k is the distance from that vertex to the start point now, and abs is the absolute value. All the left parts remain the same, we sort the edges according to their heuristic numbers, and return a central point. 4.4 Kruskal s algorithm In this section, we give our results of Kruskal s algorithm on random weighted graphs parsed from benchmark circuits. Note that our Kruskal s algorithm now is pretty far away from the original one, 9

10 and only core idea of union find set remains. We sort the edges by their heuristics, not their lengths, so that the tree we get is expected to be a low-stretch spanning tree, not a minimum spanning tree Runtime results Table 7 shows a onetime result of Kruskal s algorithm using unweighted heuristic No.1. Still, R1 is runtime for finding a central vertex, R2 is runtime for Kruskal s algorithm and R3 is runtime for calculating average stretch. Table 7: Result of Kruskal s algorithm random weighted version No.1 Benchmark No. Avg-Stretch Longest Stretch Diameter R1 R2 R Table 8 shows results of four different heuristics. No.1 and No.2 are unweighted heuristics, and No.3 and No.4 are weighted heuristics. Table 8: Different heuristics results of Kruskal s algorithm random weighted version Benchmark No. Heuristic No.1 Heuristic No.2 Heuristic No.3 Heuristic No Different weights effect on average stretch As we can see, weighted heuristic No.1 works the best for most of benchmark circuits. However, up to now, we have not used the power of Kruskal s algorithm in finding a minimum spanning tree. In unweighted graphs, this power is very small because Kruskal s algorithm is no more than a random edge selection with union find set. In weighted graphs, things change since every edge has a length, so that the mimimum property of the spanning tree may be important now. We redefine our heuristic number for weighted heuristic No.1 be a weighted sum of h[x] = h [x] w + d[x] (1 w) for each edge x, in which h is the heuristic number now, h is the previous heuristic number, and d is the length of that edge. In this way, when w = 1, it is the weighted heuristic No.1 before; when w = 0, it is pure Kruskal s algorithm. Figure 6 gives all plots on different weights effect on Kruskal s algorithm for all eight benchmarks. As we can see, 0.2 seems to be a very good weight. Table 9 gives the best results over different weights of Kruskal s algorithm. Note that all results are obtained by using weighted heuristic No.1. Since it is the best results, it would be helpful to give the average results of all benchmarks at the. Note that the means are calculated after eliminating the largest and the smallest data. 10

11 Figure 6: Different weights effect on average stretch random weighted version Kruskal 11

12 Table 9: Best results of Kruskal s algorithm random weighted version Benchmark No. Weight Avg-stretch Mean Median Off-tree edges stretch distribution Kruskal Same as unweighted version, we get the off-tree edge stretch distribution. Figure 7 shows the off-tree edges stretch distribution for random weighted graphs from benchmark 1 for Kruskal s algorithm. This figure is obtained by weighted heuristic No.1, with w = Figure 7: Stretch distribution for benchmark 1 random weighted version Kruskal As we can see from the right most of the figure, there are some edges that have very long stretches. To assure this, we get another Figure 8 for benchmark 7, with w = Figure 8: Stretch distribution for benchmark 7 random weighted version Kruskal It is very similar to benchmark 1. They suggest that finding a way to reduce the number of edges with very long stretches would be important. 12

13 4.5 Prim-Dijkstra algorithm In this section, we give our results of Prim-Dijkstra algorithm on random weighted graphs parsed from benchmark circuits Runtime results Table 10 shows a onetime result of Prim-Dijkstra algorithm using unweighted heuristic No.1. Still, R1 is runtime for finding a central vertex, R2 is runtime for Kruskal s algorithm and R3 is runtime for calculating average stretch. The results we get here are all with w = 1, though we will show later that this is not the best ratio now. Table 10: Result of Prim-Dijkstra algorithm random weighted version No.1 Benchmark No. Avg-Stretch Longest Stretch Diameter R1 R2 R Table 11 shows results of four different heuristics. No.1 and No.2 are unweighted heuristics, and No.3 and No.4 are weighted heuristics. Table 11: Different heuristics results of Prim-Dijkstra algorithm random weighted version Benchmark No. Heuristic No.1 Heuristic No.2 Heuristic No.3 Heuristic No Different weights effect on average stretch To be consistent with Kruskal s algorithm, we first get the ratio plot for weighted heuristic No.1. Figure 9 shows the result. Though the tency differs in different benchmarks, we can still see that ratio about works the best. Note that this result means that the algorithm mostly runs on Dijkstra s, with a slightly variation to Prim s algorithm. To go into more details, we give another plot for unweighted heuristic No.1, which work best for Prim-Dijkstra algorithm according to Table 11. Figure 9 shows the result. Generally the tr keeps the same and the results are better. Table 12 gives the best results over different weights of Prim-Dijkstra algorithm obtained by unweighted heuristic No.1. Same as before, we give the mean at the. The means are still calculated after eliminating the largest and the smallest data. 13

14 Table 12: Best results of Prim-Dijkstra algorithm random weighted version Benchmark No. Weight Avg-stretch Mean Median Off-tree edges stretch distribution Prim-Dijkstra Same as before, we get Figure 11 and Figure 12. As we can see, Prim-Dijkstra algorithm could give us a better off-tree stretch distribution than Kruskal s algorithm. References [1] Natarajan Viswanathan (2012). Design Hierarchy Aware Routability-driven Placement. Accessed May 20, 2013, at CAD-contest-at-ICCAD2012/problems/p2/p2.html. [2] Michael Elkin, Yuval Emek, Daniel A. Spielman, and Shang-Hua Teng. Lower-stretch spanning trees. STOC 05: Proceedings of the thirty-seventh annual ACM symposium on Theory of computing, pages , New York, New York, USA. [3] Ittai Abraham & Ofer Neiman (2012). Using Petal-Decompositions to Build a Low Stretch Spanning Tree. STOC 12, May 12-22, 2012, New York, New York, USA. [4] Kruskal s algorithm. Accessed May 20, 2013, at s_ algorithm. [5] Prim s algorithm. Accessed May 20, 2013, at algorithm. [6] Dijkstra s algorithm. Accessed May 20, 2013, at 27s_algorithm. [7] Lowest common ancestor. Accessed May 20, 2013, at Lowest_common_ancestor. [8] Range Minimum Query. Accessed May 20, 2013, at Minimum_Query. [9] Range Minimum Query and Lowest Common Ancestor. Accessed May 20, 2013, at http: //community.topcoder.com/tc?module=static&d1=tutorials&d2=lowestcommonancestor. 14

15 Figure 9: Different weights effect on average stretch random weighted version Prim-Dijkstra by weighted No.1 15

16 Figure 10: Different weights effect on average stretch random weighted version Prim-Dijkstra by unweighted No.1 16

17 Figure 11: Stretch distribution for benchmark 1 random weighted version Prim-Dijkstra Figure 12: Stretch distribution for benchmark 7 random weighted version Prim-Dijkstra 17