A New Heuristic for DSOP Minimization

Size: px

Start display at page:

Download "A New Heuristic for DSOP Minimization"

Vincent Todd
5 years ago
Views:

1 A New Heuristic for DSOP Minimization Anna Bernasconi Department of Computer Science University of Pisa, Italy Fabrizio Luccio Department of Computer Science University of Pisa, Italy Valentina Ciriani Department of Information Technologies University of Milano, Italy Linda Pagli Department of Computer Science University of Pisa, Italy Abstract We give a heuristic for Disjoint Sum-of-Products (DSOP) minimization of a Boolean function f, based on a new criterion for product selection. Starting from a Sum-of-Products (SOP) S of f, i.e., a set of cubes covering the s of f, we assign a weight w(p) to each product (cube) p in S, where w(p) depends on the intersection of p with the other cubes of S. We assign higher weight to the cubes that, if selected in DSOP, would generate a higher fragmentation of the other cubes. Disjoint cubes are then selected for increasing value of w, and possibly for decreasing size, recomputing the SOP on the residual function at different possible stages as a trade-off between quality of result and computational time. A set of experiments conducted on major benchmark functions show that our method, with all its variants, always generates better results than the ones of previous heuristics including one based on a BDD representation of f. Keywords: Sum-of-Products, Disjoint Sum-of-Products, Cube selection, Cube fragmentation, Minimal form, espresso. Introduction Given a Boolean function f on n variables x, x 2,..., x n in B n, a Disjoint Sum-of-Products (DSOP) of f is a set of products (ANDs) of subsets of variables whose sum (OR) equals f, such that no two products cover the same of f. As each product is the mathematical expression for a cube in B n, a DSOP also represents a set of non intersecting cubes occupying the points of B n in which f =. In fact we shall indifferently refer to products or cubes, and apply algebraic or set operations to them. We are interested in minimizing DSOP, i.e., finding a DSOP with a minimal number of products. Besides its theoretical interest, DSOP minimization is relevant in the area of digital circuits for determining various properties of Boolean functions, as discussed for example in [7,, ]. DSOPs are indeed used as a starting point for the synthesis of Exclusive-Or-Sum-Of-Products (EPSOPs), and for calculating the spectra of Boolean functions. For speeding an otherwise exceedingly cumbersome process an absolute minimum is not sought for, rather heuristic strategies for cube selection have been proposed, working on explicit product expressions [2, 0], or on a BDD representation of f [3]. As the standard SOP minimization is a problem similar to set covering, DSOP minimization can be compared to the set partitioning (or minimal exact cover) problem. The minimal exact cover problem can be described as follows: given a family of subset S of a set U and a positive integer k, is there a subset family T S such that the subsets in T are k in number, are disjoint, and their union is the entire set U? The minimal exact cover is NP-hard since it can be easily reduced by the exact cover problem introduced by Karp in 972 [6] setting k to the cardinality of U. We study a class of heuristic algorithms for DSOP minimization based on the new concept of cube weight, and show that our results compare favorably with the ones of the other known

2 heuristics. The starting set of cubes is the one of a SOP, found with standard heuristics. The SOP cubes may be eventually fragmented into non overlapping sub-cubes, giving rise to a largely unpredictable DSOP solution. The process may exhibit an exponential blow up in the number of fragments even dealing with theoretically minimal solutions, as for a function presented in [8] where SOP = n/2 and DSOP = 2 n/2. In the following Section 2 we define the weight of a product p as a functions of the number of fragments possibly induced on other cubes by the selection of p. In Section 3 we show how this weight can be exploited for building a class of minimization heuristics, whose results on the benchmarks of espresso are presented in Section 4 and compared with other published data. The paper is concluded in Section 5. 2 The Weight of a Cube With usual terminology, a literal y i is a variable x i in direct or complemented form. Products are made of literals. A product q = y i y i2...y ik, k n, represents a cube of dimension d(q) = n k, i.e., a cube of 2 n k points in B n. The intersection p = p p 2 of two cubes p = y i...y ik, p 2 = y j...y ih is obviously obtained as the AND of the two products. p is void iff there is a literal in p that appears complemented in p 2. Otherwise p is a cube of dimension d(p) = r, with r = n (k + h c), and c is the number of common literals in p, p 2. Take p, p 2 as above, and let p, p 2 partially overlap. The set of points of p 2 \ p can be covered by a set of k c disjoint cubes of dimensions r, r +,..., n h. For n = 6, letting k = 5, h = 3, c = 2 we have r = 0 and d(p ) =, d(p 2 ) = 3, i.e., the two cubes contain 2 and 8 points, respectively. p 2 \ p contains 7 points and can be covered with 5 2 = 3 cubes of dimensions 0,, 2. Now, if p is selected into a DSOP, p 2 must be discarded and the points of p 2 \ p must be covered with at least k c disjoint cubes instead of one (the single p 2 ). Then k c is the number of extra cubes required by the DSOP. If the function f can be represented by a SOP containing only p and p 2, the selection of p into a DSOP requires a total of k c + cubes. In particular if k c = the intersection p covers exactly one half of the points of p 2 and p 2 \ p is also a cube. Clearly the general situation will not be that simple as the starting SOP for f, to be transformed into a minimal DSOP, will consist of a collection of cubes overlapping in groups. Still we define a weight for each cube p i equal to the minimum number of extra cubes that the selection of p i would induce in all the cubes intersecting p i. Formally, let a SOP for f consist of partially overlapping products p, p 2,..., p s. We pose: Definition Let product p i of k literals intersect products p i,..., p it, such that p i and p ij have c j common literals. Then w(p i /p ij ) = k c j is the weight of p i relative to p ij, and w(p i ) = t j= w(p i/p ij ) is the weight of p i. If p i does not intersect any other product, set w(p i ) =. Thus, when p i intersects p ij, the weight of p i relative to p ij is the minimum number of additional products that we would have in the cover keeping p i and covering p i /p ij with nonoverlapping products. As an example, consider the function f of four variables, represented in the Karnaugh map of Figure (a). A minimal SOP of f contains four cubes A = x x 3, B = x 2 x 4, C = x x 2, D = x x 3 of dimension two. The weights are computed as follows. For A: w(a/b) = (in fact, selecting A in a DSOP would require to covering the remaining three points of B with at least two disjoint cubes); w(a/c) = 0 (the residual two points of C can be covered with one cube); then w(a) =. For B: w(b/a) = ; w(b/c) = 0; w(b/d) = ; then w(b) = 2. For C: w(c/a) = 0; w(c/b) = 0; then w(c) = 0. For D: w(d/b) = ; then w(d) =. As we shall explain in the next section, we start the construction of a DSOP by selecting the cubes with low weight and high dimension, breaking on the fly the ones that intersect a selected cube. In the present example, start by selecting C and reduce A and B to two subcubes A, B of two points each. Then select D and further break B. Then select A and the remaining subcube B 2 of B of one point, as shown by the DSOP in Figure (b). During the process the weights are updated as explained below.

3 x x 2 x 3 x x x 2 x 3 x A 00 A 0 C 0 C B B 2 0 D 0 D (a) (b) Figure : A minimal SOP (a) of four cubes of dimension 2 in B 4, with weights w(a) =, w(b) = 2, w(c) = 0, w(d) =, and the corresponding DSOP (b). 3 A Family of Algorithms The new heuristics for DSOP construction uses four basic procedures working on an explicit representation of cubes. The first procedure BUILD-SOP(C, P ) works on a set C of cubes covering a function f, to build a minimal (or quasi minimal) SOP P for f. As a limit the cubes of C may be minterms, i.e., cubes of dimension 0. The second procedure WEIGHT(P ) builds the weights for the cubes of a set P. The third procedure SORT(P ) sorts a set P of weighted cubes. This procedure comes in two versions: i) the cubes are ordered for decreasing dimension and, if the dimension is the same, for increasing weight; ii) the cubes are ordered for increasing weight and, if the weight is the same, for decreasing dimension. If two or more cubes have same weight and same dimension, their order is arbitrary. The two versions of SORT give rise to two different alternatives of the overall algorithm. The forth procedure BREAK(q, Q) works on the difference q = p 2 \ p between two cubes, to build an arbitrary minimal set Q of disjoint cubes covering q. Note that this operation is easy since q is obtained as the set difference between two cubes, i.e., p 2 and p p 2, which in turn is a cube because it is the intersection of two cubes. For BUILD-SOP one can use any minimization procedure (in our experiments we have used procedure espresso-non-exact of the espresso suite [2]). Procedures WEIGHT and SORT (both versions) are obvious. Procedure BREAK is the one suggested in [5, 9] as DISJOINT- SHARP. We make use of four sets of cubes C, P, B, D. At the beginning C contains the cubes defining f, while P, B, D are empty. During the processing C contains the cubes defining the part of f still to be covered with a DSOP. P contains the cubes of a SOP under processing. B temporarily contains cubes produced by BREAK as fragmentation of cubes of P. D contains the cubes already assigned to the DSOP solution and, at the end, the solution itself. The algorithms of our family share the following structure. algorithm DSOP(C, D) while (C ) { BUILD-SOP(C, P ); WEIGHT(P ); SORT(P ); while (P ) { let p be the first element of P ; move p from P to D; q P : p q { remove q from P ; BREAK(q \ p, Q); B = B Q ; *OPT* }

4 q B : p q { remove q from B; BREAK(q \ p, Q); B = B Q ; } } C = B; B = ; } *OPT* is an optional piece of code that recomputes the weight of each cube r P such that r q, checking the fragments of q with which r now intersects, and then sorts P again. For an example, Figure (b) shows a DSOP form for the SOP form of Figure (a), computed by the heuristic algorithm. We have observed experimentally that more sophisticated optimization procedures, as for instance inserting all broken cubes into P and ordering them immediately, do not seem to provide better quality results. Experimental results have also outlined how the BUILD-SOP procedure, i.e., the idea of re-synthesizing the remaining cubes, seems to be crucial for obtaining compact DSOPs. The complexity of the algorithm is polynomial in the size of the output, i.e., in the number of products of the computed DSOP form. We finally observe that while C is not empty, the algorithm iteratively builds a SOP form covering the points that are not yet covered by the DSOP solution. 4 Experimental Results In this section we present and discuss the computational results obtained by applying the heuristic presented above to the standard espresso benchmark suite [2]. All computational experiments were performed on a.8 GHz PowerPC with GB of RAM. We considered three different variants of our heuristic. The first variant, denoted by DSOP- in the following Table, is the simplest, and computationally fastest: it consists in just the basic algorithm, without the optional optimization phase *OPT*. The second variant, denoted by DSOP-2 in Table, add to the basic code the optimization phase. In particular, after a cube p has been chosen, the algorithm updates the weight of all cubes q P intersecting p, and then sorts the cubes in P again. DSOP- DSOP-2 DSOP-3 in out SOP d/w (time) w/d (time) d/w (time) w/d (time) d/w (time) w/d (time) accpla (.68) 779 (24.57) 458 (3.42) 77 (32.46) 90 (0.55) 37 (6.80) addm (0.26) 220 (0.26) 22 (0.3) 222 (0.27) 24 (0.40) 27 (0.29) b (0.3) 36 (0.32) 30 (0.33) 30 (0.33) 5 (0.49) 20 (0.39) b (0.42) 3 (0.4) 3 (0.49) 3 (0.44) 2 (0.54) 20 (0.62) b (0.78) 35 (0.73) 308 (0.88) 37 (0.77) 279 (.2) 32 (.77) bc (0.47) 230 (0.60) 24 (0.53) 28 (0.53) 202 (0.68) 20 (.8) dist (0.22) 38 (0.2) 35 (0.23) 38 (0.23) 30 (0.38) 33 (0.36) ex (0.58) 855 (0.72) 820 (0.75) 835 (0.79) 876 (.34) 893 (.42) ex (3.23) 546 (3.8) 470 (3.27) 487 (3.4) 438 (5.93) 55 (5.90) ex (0.79) 28 (0.38) 26 (0.44) 25 (0.44) 22 (0.80) 42 (0.77) gary (0.52) 39 (0.28) 34 (0.35) 3 (0.27) 24 (0.49) 32 (0.43) ibm (.23) 43 (0.69) 366 (0.59) 393 (0.64) 36 (0.99) 46 (.24) in (.36) 329 (0.72) 32 (0.84) 33 (0.8) 280 (.33) 32 (.29) intb (2.03) 955 (.79) 88 (.6) 932 (.83) 798 (2.57) 25 (3.65) jbp (0.57) 5 (0.35) 35 (0.26) 47 (0.36) 27 (0.43) 28 (0.33) mainpla (4.67) 459 (2.86) 296 (3.00) 405 (2.47) 293 (3.23) 387 (3.33) misex (2.72) 32 (.28) 073 (.49) 55 (.75) 032 (2.68) 37 (4.58) soar (.93) 45 (.6) 447 (.30) 449 (.25) 434 (.58) 430 (.4) spla (0.83) 363 (0.43) 359 (0.44) 363 (0.44) 347 (0.64) 36 (0.86) table (0.4) 8 (0.2) 8 (0.23) 8 (0.24) 80 (0.33) 80 (0.24) table (0.39) 67 (0.3) 67 (0.36) 67 (0.32) 6 (0.38) 6 (0.28) test (.69) 365 (.3) 363 (.36) 364 (.8) 462 (.8) 454 (.84) tial (.78) 2 (2.22) 937 (.96) 060 (2.3) 874 (2.98) 37 (6.68) Table : Comparison of three different variants of the DSOP minimization heuristic. The size of the best DSOP representation computed for each benchmark is in boldface. A disadvantage of both versions is that whenever a cube p is moved from P to D, all cubes q intersecting p are fragmented and removed from the set P. Hence, the fragments, even the big ones, are out of the game and cannot partecipate in the construction of the DSOP D until P becomes empty and a new SOP covering all fragments in the set B is computed. Consequentially, small cubes in P could be selected first, possibly damaging the quality of the final result, i.e., the size of the DSOP. To partially avoid this disadvantage, we implemented a third version of the heuristic (DSOP-3 in Table ), in which whenever a cube p P is selected and moved to D, each cube q intersecting p is, as before, fragmented and moved to B, and, in addition, all cubes r P intersecting q are moved to B as well. In this way, we prevent small and high weight

5 Bench in out PLA SOP DSOP DSOP DSOP DSOP espr. [2] [0] [3] DSOP 5xp sym alu b clip co max misex misex mlp rd rd rd sym t x7dn xor Table 2: Comparison to other techniques cubes of P from generating high fragmentations of big fragments of low weight cubes already in B. This version of the heuristic is computationally more expensive, since in the internal while loop less cubes can be selected (P empties faster), and procedure BUILD-SOP must be executed more frequently. For each variant, we run both versions of the procedure SORT, in order to estimate the practical effectiveness of either version. We first ordered the cubes for decreasing dimension and, for equal dimension, for increasing weight (this version is denoted by d/w in Table ); then we ordered the cubes for increasing weight and, for equal weight, for decreasing dimension (this version is denoted by w/d). Since the benchmarks are multi-output functions and the algorithm is described for single output function, in the experiments we have considered each output separately, but the minimization phase with espresso is performed in a multi-ouput way. Moreover common disjoint cubes of several output are counted only once. Table reports a subset of the experiments: the first column of the table reports the name of the benchmark; the following two columns the number of inputs and outputs; the column labelled SOP shows the number of products in a SOP representation computed by espressonon-exact; finally the three pairs of columns report the number of disjoint products in the DSOP expressions computed by our heuristics. In each column we have reported the cost and the corresponding synthesis time. As Table clearly shows, the third variant of the heuristic, together with the first version of procedure SORT (d/w), gives the best results regarding the size of the resulting DSOP forms, and its running times are often lower then the times of the two first variants. In a second series of experiments we compared our heuristic to other DSOP minimization methods. We considered two techniques working, as ours, on explicit representation of cubes, and one method based on binary decision diagrams. The first algorithm [2] sorts cubes in a minimal SOP according to their size, and compares the largest cube with all the others, starting from the smallest ones. In the next step, the second largest cube is selected and compared to all smaller ones, etc. As a last step, the cubes are merged, where possible. The second algorithm, presented in [0], exploits the property of the most binate variable in a set of cubes to compute a DSOP form. Finally, the third approach, presented in [3], makes use of BDDs, exploiting the efficiency resulting from the implicit representation of the products. Observe in fact that a DSOP form can be extracted in a straightforward way from a BDD, as different one-paths correspond to disjoint cubes. Table 2 reports a cost-oriented comparison among the different methods. The first column reports the name of the instance; the following four columns report the number of inputs and outputs, and the number of products in the PLA realization and in the SOP form heuristically

6 minimized by espresso-non-exact. The column labeled DSOP espr. shows the size of the DSOP computed running espresso with the option -Ddisjoint on the previously computed SOP form. The next three columns report the sizes, when available, of the DSOP forms computed with the methods discussed in [2], [0], and [3], respectively. Finally, the last column shows the size of the DSOPs computed with our heuristic (third variant). As the table clearly shows, our method always generates smaller DSOP representations, and the gain in size can be quite striking, as for instance for the benchmarks alu4, clip, and t48. Note that, even considering the first two variants of the heuristic, and the different sorting criterion, our technique almost always compares favorably. A time comparisons among all these different methods was not possible due to the partial absence of CPU times in the literature. 5 Conclusions and Future Work Although deriving an optimal DSOP representation of a Boolean function is a hard problem, we have described a heuristic, based on a new criterion for product selection, that has been implemented and tested with interesting results. As future work on this subject, we plan to evaluate the time performances of our heuristic on very large benchmarks, and compare them with other methods, especially with the one based on BDDs. Cubes are currently explicitly represented; it would be interesting to use implicit data structures (e.g., BDDs) and symbolically perform all the operations in the heuristic. From a more theoretic prospective, it could be an interesting development to study more deeply the approximability properties of DSOP minimization, with the aim of designing approximation algorithms, instead of heuristics. Recall that a p-approximation algorithm for a minimization problem always yields solutions whose cost C is pc, where C is the cost of an optimal solution [4]. Thus, both heuristics and approximation algorithms do not guarantee the minimality of their solutions, but an approximation algorithm guarantees near-optimum solutions, whereas we cannot perform any prediction on the result of a heuristic. As a first step in this direction we should understand when our heuristic returns a DSOP whose cost is much higher then the cost of an optimal DSOP. References [] B.J. Falkovsky and C.-H. Chang. Paired Haar Spectra Computation Through Operations on Disjoint Cubes. IEEE Proc. on Circuits, Devisces, and Systems (999) [2] B.J. Falkovsky,I. Schäfer, and C.-H. Chang. An Effective Computer Algorithm for the Calculation of Disjoint Cube Representation of Boolean Functions. Proc. IEEE International Midwest Symp. on Circuits and Systems (993) [3] G. Fey and R. Drechsler. Utilizing BDDs for Disjoint SOP Minimization. Proc. IEEE International Midwest Symp. on Circuits and Systems 2 (2002) [4] M. R. Garey and D. S. Johnson. Computer and Intractability: A Guide to the Theory of NPcompleteness. W.H. Freeman and Company (979). [5] S. J. Hong, R. G. Cain and D. L. Ostapko. MINI: A Heuristic Approach for Logic Minimization. IBM Journal of Research and Development 8 (5) (974) [6] R. M. Karp Reducibility Among Combinatorial Problems. in R. E. Miller and J. W. Thatcher (editors): Complexity of Computer Computations. New York: Plenum Press (972), [7] T. Sasao. EXMIN2: A Simplification Algorithm for Exclusive-OR-Sum-of -Products Expression for Multiple-Valued-Input Two-Valued-Output functions. IEEE Trans. on Computer Aided Design 2 (993) [8] T. Sasao. A Design Method for AND-OR-EXOR Three-Level Networks. Proc. ACM/IEEE International Workshop on Logic Synthesis (995) 8:-8:20. [9] T. Sasao. Switching Theory for Logic Synthesis, Kluwer Academic Publishers (999). [0] L. Shivakumaraiah and M. Thornton. Computation of Disjoint Cube Representation Using a Maximal Binate Variable Heuristic. Proc. Southeastern Symp. on System Theory (2002) [] M.A. Thornton, R. Drechsler, and D.M. Miller. Spectral Techniques in VLSI CAD. Kluwer Academic Publ., 200. [2] S. Yang. Synthesis on Optimization Benchmarks. User guide, Microelectronic Center, 99. Benchmarks at: ftp://ftp.sunsite.org.uk/computing/general/espresso.tar.z.

SEPP: a New Compact Three-Level Logic Form

SEPP: a New Compact Three-Level Logic Form Valentina Ciriani Department of Information Technologies Università degli Studi di Milano, Italy valentina.ciriani@unimi.it Anna Bernasconi Department of Computer