VLSI Great Lakes Symposium, pp 248-251, Notre Dame, IN, March 1994
An ADD-Based Algorithm for Shortest Path Back-Tracing of Large Graphs R. I. Bahar
G. D. Hachtel
E. Macii
A. Pardo
M. Poncino
F. Somenzi
University of Colorado Dept. of Electrical and Computer Engineering Boulder, CO 80309
Abstract
Symbolic computation techniques play a fundamental role in these days logic synthesis and formal hardware veri cation algorithms. Recently, Algebraic Decision Diagrams, i.e., BDD's with a set of constant values di erent than the set f0 1g, have been used to solve general purpose problems, such as matrix multiplication, shortest path calculation, and solution of linear systems, as well as logic synthesis and formal veri cation problems, such as timing analysis, re-synthesis for low-power, probabilistic analysis of FSM's, and state space decomposition for approximate FSM traversal. ADD-based procedures for single-source and all-pairs shortest path weight calculation have appeared to be very e ective for the manipulation of large graphs (over 1027 vertices and 1036 edges). However, for those procedures to be applicable to real problems, for example ow network problems, computing only shortest path weights is not enough; what it is needed is an algorithm that, given the weight of a shortest path between two vertices of a graph, actually determines the sequence of vertices belonging to the shortest path. In this paper, we propose a symbolic algorithm for shortest path back-tracing which exploits the compactness of the ADD data structure to handle large graphs. ;
Paper Category 9. Graph Theory Application to VLSI
Contact Person Enrico Macii University of Colorado Dept. of Electrical and Computer Engineering Campus Box 425 Boulder, CO 80309 Phone: (303) 492-1135 Fax: (303) 492-2758 E-mail:
[email protected]
0
1 Introduction Binary Decision Diagrams (BDD's) [1, 2], combined with symbolic graph algorithms, have been successfully used to solve dicult problems in the elds of logic synthesis, formal hardware veri cation, and circuit testing. Recently [3, 4], we have proposed a new kind of BDD, called Algebraic Decision Diagram (ADD), whose main feature is the adoption of multiple terminal nodes; in other words, an ADD is a BDD whose leaves may assume constant values di erent from 0 and 1. In order to investigate the usefulness of this new data structure, ADD's have been applied rst to general purpose problems, such as matrix multiplication, single-source and all-pairs shortest path calculation, direct (Gaussian Elimination, LU factorization, etc.) and iterative methods (GaussSeidel, Gauss-Jacobi, etc.) for the solution of systems of linear equations. Experimental results have shown the e ectiveness of these algorithms in the treatment of problems of large sizes. Therefore, we have started using ADD's to solve logic synthesis and formal veri cation problems. More speci cally, in [5] we have presented symbolic algorithms to perform accurate timing analysis of combinational circuits, and in [6] we have used ADD's to re-synthesize combinational circuits for low power. From the formal veri cation side, the subject of [7] has been the symbolic calculation of the steady-state probabilities of large, but structurally simple, nite state machines, while in [8] we have extended the algorithms to deal with FSM's having arbitrarily complex transition structure; nally, in [9, 10] we have used ADD's to manipulate graphs in the context of realizing state space decomposition procedures for approximate FSM traversal [11]. The symbolic shortest path algorithms we have presented in [3] eciently determine the weights of the shortest paths between pairs of vertices of a graph; however, they do not keep track of the the sequence of vertices forming the paths. This information may be important in several applications of shortest path algorithms to logic synthesis and formal veri cation problems; for example, in [12] all-pairs shortest path procedures have been used in the process of verifying nite state concurrent systems; other possible uses are in the solution of ow networks [13]. In this paper, we present an ADD-based algorithm that, given the adjacency matrix of a graph, AG , the matrix of the shortest path weights, S , and a pair of vertices, source and sink, determines all the shortest paths between source and sink. In general, the number of shortest paths yielding the same shortest path weight may be extremely large. The symbolic procedure we propose here, which is based on the triangulation rule described in Section 3.2, implicitly enumerates all of them. For the sake of clarity in the explanation, we have restricted ourselves to the case of single-source shortest path; however, the generalization of the algorithm to all-pairs shortest path is straight-forward. The rest of this paper is organized as follows. Section 2 gives de nitions and notation on weighted directed graphs, ADD's, and ADD-based shortest path algorithms. In Section 3 we detail the symbolic procedure for shortest path back-tracing, and in Section 4 we report on the experimental results we have obtained on some large graphs. Finally, Section 5 is devoted to conclusions and directions for future work.
2 Preliminaries 2.1 Weighted Directed Graphs A weighted directed graph (or weighted digraph) G is a triple (V; E; w), where V is a nite set, E is a binary relation on V , and w is a function from E to R. The set V is called the vertex set (or node set) of G, and its elements are called vertices (or nodes). The set E is called the edge set of G; its elements are called edges and are ordered pairs of vertices; for example, if there is an edge going from vertex vi to vertex vj of G, we indicate such an edge as (vi ; vj ). Note that self-loops (edges from a vertex to itself) are possible. Edges entering a vertex are called in-coming edges, edges leaving a vertex are called out-going edges. The in-degree of a vertex u of G is the number of its in-coming edges, while the out-degree of u is the number of its out-going edges. The function w : E 7! R, is called weight function, and associates a weight to each edge in E . If (vi ; vj ) is an edge in a weighted directed graph G = (V; E; w), then we write vi ! vj , and we say that vertex vj is adjacent to vertex vi . Note that the adjacency relation in a directed graph is not necessarily symmetric. 1
A path, p, of length k from a vertex u to a vertex v in a weighted directed graph G = (V; E; w) is a sequence hv0 ; v1 ; : : : ; vk i of vertices such that u = v0 , v = vk , and (vi?1 ; vi ) 2 E , for i = 1; 2; : : :; k; p contains the vertices v0 ; v1 ; : : : ; vk and the edges (v0 ; v1 ), (v1 ; v2 ), : : :, (vk?1 ; vk ). If there exists a path p connecting vertex u to vertex v, then we write u !p v, and we say that v is reachable from u via p. If all the vertices of p are distinct, then p is simple. The length of p is the number of edges in the path, while the weight of p is the sum of the weights of its constituent edges:
w(p) =
k X i=1
wi?1;i ;
where wi?1;i = w(vi?1 ; vi ) is the weight associated to edge (vi?1 ; vi ) 2 E . Given two vertices u; v 2 V of G, the shortest-path weight from u to v is de ned as: p minfw(p) : u ! vg if there is a path from u to v, (u; v) = 1 otherwise. A shortest path from vertex u to vertex v is then de ned as any path p of weight w(p) = (u; v). In a weighted directed graph, G(V; E; w), a path p = hv0 ; v1 ; : : : ; vk i forms a cycle if v0 = vk ; the cycle is simple if v1 ; : : : ; vk are distinct. A self-loop is a cycle of length 1. If G has no self-loops, then it is simple. A weighted directed graph, G = (V; E; w), can be represented as a square matrix, AG (aij ), called the adjacency matrix of G. AG has as many rows and as many columns as the number of vertices of G, jV j; each entry, aij , of AG is such that: if (vi ; vj ) 2 E , aij = 0wij otherwise.
2.2 Algebraic Decision Diagrams (ADD's) An ADD is a directed acyclic graph (V [ [ T; E ), representing a set of functions fi : f0; 1gn ! S , where S is the nite carrier of the algebraic structure over which the ADD is de ned. V is the set of the internal nodes. The out-degree of v 2 V is 2. The two outgoing arcs for a node v 2 V are labeled then and else, respectively. Every node v 2 V has a label l(v) 2 f0; : : : ; n ? 1g. The label identi es a variable on which the fi 's depend. is the set of the function nodes: The out-degree of 2 is 1 and its in-degree is 0. The function nodes are in one-to-one correspondence with the fi 's. T is the set of terminal nodes. Each terminal node t is labeled with an element of S , s(t). The out-degree of a terminal node is 0. E is the set of edges connecting the nodes of the graph; (vi ,vj ) is the edge connecting node vi to vj . The variables of the ADD are ordered; if vj is a descendant of vi (i.e., (vi ; vj ) 2 E ), then l(vi ) < l(vj ). An ADD represents a set of boolean functions, one for each function node, de ned as follows: 1. The function of a terminal node, t, is the constant function s(t). The constant s(t) is interpreted as an element of a boolean algebra larger than or equal in size to S . 2. The function of a node v 2 V is given by l(v) fthen + l(v)0 felse, where `' and `+' denote boolean conjunction and disjunction, and fthen and felse are the functions of the then and else children. 3. The function of 2 is the function of its only child. ADD's are a natural symbolic representation of weighted directed graphs, which are in one to one correspondence with square matrices. For example, the weighted directed graph of Figure 1-a, whose adjacency matrix is shown in Figure 1-b, can be represented with the ADD of Figure 1-c. In this ADD, and throughout the sequel, the open circle on an edge emanating from a node identi es the else child of the node. In this particular case, we have S f0; 3; 50g; each path corresponding to an edge not in G reaches the terminal value 0. Notice that, for the sake of clarity, we have not taken into account leaves recombination in drawing the picture of the ADD. For a more detailed treatment of Algebraic Decision Diagrams, the reader is invited to refer to [3, 4]. 2
y0 y1
S2 50
50 S3
3
S0 50
0 0 1 1
3
50 S1
00
01 10 11
0 0 0 0
50 50 0 0 3 50 0 0 50 0 0 3
0 1 0 1
x0 x1
(a)
(b)
State Encoding:
A
S0 -> 00 S1 -> 01 S2 -> 10 S3 -> 11
x0 y0
y0
x1
y1
3
50
x1
y1
y1
0
x1
0
50
0
y1
3
0
y1
0
50
50
0
(c)
Figure 1: A Weighted Directed Graph (a), its Adjacency Matrix (b), and the Corresponding ADD (c).
2.3 ADD-Based Shortest Path Algorithms Calculating shortest paths is a graph problem for which sophisticated solution algorithms are available in the literature (see, for example, [14]). Dijkstra's and Bellman-Ford procedures eciently treat the single-source shortest path problem (i.e., the problem of nding a shortest path from a given source vertex, u 2 V , to a given destination vertex, v 2 V ), while Repeated Squaring, Floyd-Warshall, and Johnson's algorithms focus on all-pairs shortest path (i.e., nding a shortest path from u 2 V to v 2 V , for every pair of vertices u and v). All the methods above are based on traditional matrix manipulation techniques; therefore, their major limitation concerns the sizes of the graphs they are able to handle. In [3], as an example of application of Algebraic Decision Diagrams, we have presented ADD-based shortest path algorithms; in particular, we have shown how symbolic realizations of Bellman-Ford, Repeated Squaring, and Floyd-Warshall procedures can be e ectively used to process graphs with more than 1027 vertices and more than 1036 edges. In the case of single-source shortest path calculations, the Bellman-Ford algorithm takes, as inputs, the adjacency matrix, AG , of the graph G(V; E; w), and the source vertex, s 2 V , and returns the vector Ss = (ds;v ), 8 vi 2 V of the shortest path weights between the source vertex s and every vertex vi of G. Similarly, in the case of all-pairs shortest path, both Repeated Squaring and Floyd-Warshall procedures take the adjacency matrix, AG , of the graph G(V; E; w) as input parameter, and return the matrix S = (dv ;v ), 8 vi ; vj 2 V of the shortest path weights between every pair of vertices vi ; vj of G. i
i
3
j
3 Symbolic Shortest Path Back-Tracing 3.1 Problem Formulation The problem we would like to solve can be stated as follows: Given the adjacency matrix of a graph, AG , the matrix of the shortest path weights, S , and a pair of vertices, source and sink, determine all the shortest paths between source and sink. In other words, given the shortest path weight (source; sink) between nodes source and sink, determine all the paths pi such that w(pi ) = (source; sink). In general, there may exist several shortest paths yielding the same shortest path weight. The symbolic method we propose implicitly enumerates all of them. Notice that here we consider the case of single-source shortest path. Therefore, matrix S = (S1 ; : : : ; SjV j ) is actually a row vector which gives all the shortest path weights from the source vertex to all the other vertices of the graph. The extension to the case of all-pairs shortest path is straight-forward.
3.2 Triangulation The method we present is essentially based on the triangulation rule. Consider the example of Figure 2; thick arrows represent segments of shortest paths. While going backward from vertex c, we add vertex b to the path if and only if wab + wbc wac . Otherwise we only add vertex a. b
w
wbc
ab
a
wac
c
Figure 2: Triangulation Example. More generally, let u and v be two vertices of the graph, and let T = (t1 ; : : : ; tm ) be the set of the vertices laying on all the paths between u and v (u may belong to T , that is, there may be an edge connecting u to v). Then, we add to the shortest path all the nodes ti 2 T for which wt v + S t S v ; that is, all the nodes ti 2 T for which the sum of the edge weight wt v with entry St 2 S equals the smallest weight between source and node v, i.e., (source; v). i
i
i
i
3.3 The Algorithm Using the triangulation rule, we can write the symbolic back-tracing algorithm in ADD form. The procedure takes as parameters the ADD representing the adjacency matrix of the graph, AG , the ADD of the matrix of the shortest path weights, S , and the ADD's of the source (source) and sink (sink) nodes. As mentioned before, the algorithm we describe here considers the case of single-source shortest path; therefore, S is a vector. For the same reason, the ADD for source is always the characteristic function of a single node. The set of vertices denoted by sink contains, in the general case, several vertices, since we want to simultaneously back-trace all the vertices along shortest paths. Figure 3 presents the high-level pseudo-code of the back-tracing algorithm in ADD form. The algorithm starts by initializing the result matrix, path, with the empty graph, and the set of visited nodes, visited to the empty set. The empty graph is represented by a constant ADD whose only leaf has the value +1, the background value for all the ADD's of this particular application. 4
procedure Shortest Path BackTrace (AG ,
i = 0;
S , source, sink) f
pathi = addConst(+1); visited = addConst(0); while (sinki != addConst(0)) f E i = AG + sinki ; Ki = S + Ei; i Kmatch = addMatch (K i ; S ); i i k 0 = 9y Kmatch ; i k = addMask(ki,sinki ); pathi = UpdatePath (pathi , ki 0 ); visited = visited + ki 0 ki 00 = addMask (ki0 ,source); sinki+1 = ki 00 ; sinki+1 = sinki+1 ? visited; i = i + 1;
g
g
return
path;
Figure 3: Shortest Path Back-Tracing Algorithm in ADD Form. At each iteration, given the characteristic function of the sink nodes, the predecessors of the current sink are computed (ADD E ), and added to the matrix of the shortest path weights S , to obtain K . The ADD K is the characteristic function of those vertices x connecting the vertices given by sink. addMatch is a recursive procedure that performs a minterm-by-minterm comparison of two ADD's. If the value of two minterms is the same, the procedure returns this value, otherwise it returns +1, the background value. The resulting ADD, Kmatch, is therefore the characteristic function of the predecessor vertices of sink which do not violate the triangulation rule. By abstracting y from Kmatch we get k, which is a minterm that evaluates to one in the rows corresponding to the valid predecessors computed so far. The sink itself is included in this set and therefore k(y) is masked (procedure addMask) with the sink values, and added to the current path (procedure UpdatePath). Notice that, if k 0 contains the source node, this is correctly taken into account in updating the global path. Procedure addMask produces on k the e ect of masking the columns di erent from the desired ones, i.e., the columns of sink, because sink is actually a minterm with 0 as foreground value and in nity as background value. A set of visited nodes, visited, is kept in order to avoid visiting the same node more than once. Furthermore, this is the condition to prevent back-tracing along negative or zero-weight cycles. If the set of the predecessors k0 includes the source node, we mask it with the source value (ADD k00 ), since we do not need to back-trace along this path further. Finally, k00 is masked with any already visited node, and eventually assigned to sink. Here, addMask masks the columns of k0 which are di erent from the desired columns of source. The valid predecessors represented by k00 become the new sinks for the next iteration. The procedure returns an acyclic sub-graph of the original graph, which contains all the paths from source to sink of smallest weight.
3.4 An Application Example
As an example, we illustrate the trace of execution of the algorithm of Figure 3 on the simple graph of Figure 4. Figure 4-a, shows the original graph, together with its adjacency matrix and the matrix of the shortest path weights, where node 0 is assumed to be the source vertex (thick circle). The shaded circle (node 1) represents the sink vertex. Figure 4-b shows an execution of the algorithm; matrix names match the ones in the pseudo-code of Figure 3, while the superscripts give the values of the matrices at di erent iteration steps. The example completes in three iterations. Notice that some of the operations on the matrices shown in the pseudo-code may be quite far from the actual ADD implementation. For example, consider the ADD E , obtained by adding AG to sink. 5
This is a true summation provided that, say, sink is a minterm whose background value is +1, and foreground value is 0. Figure 4-c shows the resulting sub-graph and the relative matrix returned by the algorithm.
3.5 Negative Cycles Traditional shortest path algorithms are able to detect the existence of negative cycles. In the presence of negative cycles, the computation of the shortest paths is not meaningful, since we can always nd an arbitrarily short shortest path by repeatedly iterating in the negative cycle. Shortest path algorithms typically return the rst occurring negative weight cycle. However, the ability to detect negative cycles is important in the solution of ow network problems, for example the minimum cost ow problem [15]. Therefore, it is desirable for a symbolic algorithm to nd the maximum possible number of these negative cycles. Our algorithm prevents the back-tracing of negative (or zero) weight cycles, thus implicitly recording all the occurrences of these cycles.
4 Experimental Results The key of using ADD structures to implement the shortest path algorithms is that we are able to take advantage of the structure of the given graph by recombining like structures and representing them in the same ADD. In our experiments we have found that even for graphs with more than 1027 vertices, their corresponding ADD's have been fairly manageable in size. We have run our shortest path back-tracing algorithm on state transition graphs of some large sequential benchmark circuits; these circuits represent currently the most readily available source of very large graphs, and they have been extracted from the topological description of the circuit by building the corresponding transition relation with a symbolic traversal algorithm [16]. For these graphs, the source vertex has been chosen by randomly picking a minterm belonging to the set of the initial states of the circuit, speci ed in the traversal phase. Similarly, the sink has been chosen by randomly picking a minterm belonging to the set of reached states at a given iteration of the traversal. Table 1 presents preliminary results we have obtained with our shortest path back-tracing algorithm, together with the statistics about the graphs we have experimented with (i.e., number of vertices and number of edges); in particular, SP Time gives the time, in seconds, for the shortest-path analysis, and BT Time the time, in seconds, for the execution of the back-tracing algorithm. Notice that CPU times reported for the shortest path analysis slightly di er from the ones we have presented in [3]. Performance degradation is due to the fact that the current version of the code has been compiled without any optimization ag enabled.
5 Conclusions and Future Work For symbolic shortest path algorithms to be applicable to real problems, computing only shortest path weights in the way shown in [3] is not sucient. What it is needed is a procedure that, given the weight of a shortest path between two vertices of a graph, actually determines the sequence of vertices belonging to the shortest path. In this paper we have presented an ADD-based algorithm that implicitly executes shortest path back-tracing. The high compactness of the ADD data structure, together with the ecient implementation of the procedure, allowed us to e ectively manipulate graphs of large sizes (over 1027 vertices) in very short times. The code we have developed works for single-source shortest path; we are currently extending it to deal with the more general all-pairs shortest path; preliminary ndings are very promising, and we will report extensively on the results for this case in the nal version of the paper, if accepted. Furthermore, we are working on the application of shortest path algorithms to the solution of the minimum cost ow problem. 6
1 2
0 2 4 -2 2 0 -1 0
-1 4
0
2
A = G
S = 0
2
3
-2
2 -2
5 0
5 3 (a)
1
E =
2
2
2
2
0 -1
1
1
K = K match
1
=
k’ =
2
2
2 1
2
1
Path =
k" =
-1
sink = 0
2
1
0
4
4 2
2
E =
0
2
2
K =
0 5
K match =
3
k’ =
3
3
3
3
2 2 2
Path =
-1
-2 2
3
3
2
sink = 0
k" =k’
0 5
3
3
3
k’ =
2
2 2
-2
3
4 sink = 0
3
Path =
-1
k" =
0 5
(b)
1 2
2
-1 2
0 -2
1
-2
K match=
0
0
-2
-2 4
K =
E =
0
Path =
-2
-1 5
5 3 (c)
Figure 4: An Application Example. 7
0
0
0
Graph # of Vertices # of Edges SP Time BT Time mm2 64 512 0.04 0.03 s1488 64 133 0.14 0.42 s208 256 511 0.05 0.25 s298 1.64e+4 8.14e+4 0.28 1.35 s349 3.28e+4 2.15e+6 1.59 1.05 s1238 2.62e+5 3.56e+8 20.83 6.23 s400 2.10e+6 1.05e+7 21.51 64.71 s953 5.37e+8 5.98e+9 0.69 1.73 mm9 1.34e+8 1.37e+11 0.22 0.28 mm30 1.24e+27 2.66e+36 1.22 0.99
Table 1: Experimental Results.
References [1] R. Bryant, \Graph-Based Algorithms for Boolean Function Manipulation", IEEE Transactions on Computers, Vol. C-35, No. 8, pp. 79-85, August 1986. [2] K. S. Brace, R. Rudell, R. Bryant, \Ecient Implementation of a BDD Package", DAC-27: ACM/IEEE Design Automation Conference, pp. 40-45, Orlando, FL, June 1990. [3] R. I. Bahar, E. A. Frohm, C. M. Gaona, G. D. Hachtel, E. Macii, A. Pardo, F. Somenzi, \Algebraic Decision Diagrams and their Applications", ICCAD-93: ACM/IEEE 1993 International Conference on Computer Aided Design, Santa Clara, CA, November 1993. [4] R. I. Bahar, E. A. Frohm, C. M. Gaona, G. D. Hachtel, E. Macii, A. Pardo, F. Somenzi, Algebraic Decision Diagrams and their Applications, Internal Report, VLSI/CAD Research Group, Dept. of ECE, University of Colorado at Boulder, April 1993. [5] R. I. Bahar, H. Cho, G. D. Hachtel, E. Macii, F. Somenzi, \Timing Analysis of Combinational Circuits using ADD's," EDAC-94: IEEE European Conference on Design Automation, Paris, France, February 1993, To Appear. [6] R. I. Bahar, H. Cho, G. D. Hachtel, E. Macii, F. Somenzi, \Reducing Power Consumption of CMOS Combinational Circuits by Gate Re-Mapping" DAC-31: ACM/IEEE Design Automation Conference, San Diego, CA, June 1994, Submitted for Publication. [7] G. D. Hachtel, E. Macii, A. Pardo, F. Somenzi, \A Symbolic Algorithm to Calculate FSM Steady-State Probabilities", EDAC-93: IEEE European Conference on Design Automation, Paris, France, February 1994, To Appear. [8] G. D. Hachtel, E. Macii, A. Pardo, F. Somenzi, \Probabilistic Analysis of Large Finite State Machines", DAC-31: ACM/IEEE Design Automation Conference, San Diego, CA, June 1994, Submitted for Publication. [9] H. Cho, G. D. Hachtel, E. Macii, M. Poncino, F. Somenzi, \A State Space Decomposition Algorithm for Approximate FSM Traversal", EDAC-93: IEEE European Conference on Design Automation, Paris, France, February 1994, To Appear. [10] H. Cho, G. D. Hachtel, E. Macii, M. Poncino, F. Somenzi, \Exploiting Circuit Structure in Decomposing the State Space of Large Finite State Machines for Approximate Traversal", DAC-31: ACM/IEEE Design Automation Conference, San Diego, CA, June 1994, Submitted for Publication. [11] H. Cho, G. D. Hachtel, E. Macii, B. Plessier, F. Somenzi, \Algorithms for Approximate FSM Traversal", DAC-30: ACM/IEEE Design Automation Conference, pp. 25-30, Dallas, TX, June 1993. [12] D. L. Dill, \Timing Assumptions and Veri cation of Finite-State Concurrent Systems," Automatic Veri cation Methods for Finite State Systems, Lecture Notes in Computer Science, Vol. 407, pp. 197-212, 1990. [13] G. D. Hachtel, F. Somenzi, \A Symbolic Algorithm for Maximum Flow in 0-1 Networks", ICCAD-93: ACM/IEEE International Conference on Computer Aided Design, Santa Clara, CA, November 1993. [14] T. H. Cormen, C. E. Leiserson, R. L. Rivest, An Introduction to Algorithms, McGraw-Hill, New York, 1990.
8
[15] C. Papadimitriou, K. Steiglitz, Combinatorial Optimization: Algorithms and Complexity, Prentice-Hall, Englewood Cli s, 1982. [16] O. Coudert, C. Berthet, J. C. Madre, \Veri cation of Sequential Machines Using Boolean Functional Vectors", IFIP Intl. Workshop on Applied Formal Methods for Correct VLSI Design, pp. 111-128, Leuven, Belgium, November 1989.
9
