source: vis_dev/glu-2.3/src/cuBdd/cuddDecomp.c@ 104

Last change on this file since 104 was 13, checked in by cecile, 15 years ago

library glu 2.3
File size: 62.5 KB
Line 
1/**CFile***********************************************************************
2
3 FileName [cuddDecomp.c]
4
5 PackageName [cudd]
6
7 Synopsis [Functions for BDD decomposition.]
8
9 Description [External procedures included in this file:
10 <ul>
11 <li> Cudd_bddApproxConjDecomp()
12 <li> Cudd_bddApproxDisjDecomp()
13 <li> Cudd_bddIterConjDecomp()
14 <li> Cudd_bddIterDisjDecomp()
15 <li> Cudd_bddGenConjDecomp()
16 <li> Cudd_bddGenDisjDecomp()
17 <li> Cudd_bddVarConjDecomp()
18 <li> Cudd_bddVarDisjDecomp()
19 </ul>
20 Static procedures included in this module:
21 <ul>
22 <li> cuddConjunctsAux()
23 <li> CreateBotDist()
24 <li> BuildConjuncts()
25 <li> ConjunctsFree()
26 </ul>]
27
28 Author [Kavita Ravi, Fabio Somenzi]
29
30 Copyright [Copyright (c) 1995-2004, Regents of the University of Colorado
31
32 All rights reserved.
33
34 Redistribution and use in source and binary forms, with or without
35 modification, are permitted provided that the following conditions
36 are met:
37
38 Redistributions of source code must retain the above copyright
39 notice, this list of conditions and the following disclaimer.
40
41 Redistributions in binary form must reproduce the above copyright
42 notice, this list of conditions and the following disclaimer in the
43 documentation and/or other materials provided with the distribution.
44
45 Neither the name of the University of Colorado nor the names of its
46 contributors may be used to endorse or promote products derived from
47 this software without specific prior written permission.
48
49 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
50 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
51 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
52 FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
53 COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
54 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
55 BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
56 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
57 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
58 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
59 ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
60 POSSIBILITY OF SUCH DAMAGE.]
61
62******************************************************************************/
63
64#include "util.h"
65#include "cuddInt.h"
66
67/*---------------------------------------------------------------------------*/
68/* Constant declarations */
69/*---------------------------------------------------------------------------*/
70#define DEPTH 5
71#define THRESHOLD 10
72#define NONE 0
73#define PAIR_ST 1
74#define PAIR_CR 2
75#define G_ST 3
76#define G_CR 4
77#define H_ST 5
78#define H_CR 6
79#define BOTH_G 7
80#define BOTH_H 8
81
82/*---------------------------------------------------------------------------*/
83/* Stucture declarations */
84/*---------------------------------------------------------------------------*/
85
86/*---------------------------------------------------------------------------*/
87/* Type declarations */
88/*---------------------------------------------------------------------------*/
89typedef struct Conjuncts {
90 DdNode *g;
91 DdNode *h;
92} Conjuncts;
93
94typedef struct NodeStat {
95 int distance;
96 int localRef;
97} NodeStat;
98
99
100/*---------------------------------------------------------------------------*/
101/* Variable declarations */
102/*---------------------------------------------------------------------------*/
103
104#ifndef lint
105static char rcsid[] DD_UNUSED = "$Id: cuddDecomp.c,v 1.44 2004/08/13 18:04:47 fabio Exp $";
106#endif
107
108static DdNode *one, *zero;
109long lastTimeG;
110
111/*---------------------------------------------------------------------------*/
112/* Macro declarations */
113/*---------------------------------------------------------------------------*/
114
115
116#define FactorsNotStored(factors) ((int)((long)(factors) & 01))
117
118#define FactorsComplement(factors) ((Conjuncts *)((long)(factors) | 01))
119
120#define FactorsUncomplement(factors) ((Conjuncts *)((long)(factors) ^ 01))
121
122/**AutomaticStart*************************************************************/
123
124/*---------------------------------------------------------------------------*/
125/* Static function prototypes */
126/*---------------------------------------------------------------------------*/
127
128static NodeStat * CreateBotDist (DdNode * node, st_table * distanceTable);
129static double CountMinterms (DdNode * node, double max, st_table * mintermTable, FILE *fp);
130static void ConjunctsFree (DdManager * dd, Conjuncts * factors);
131static int PairInTables (DdNode * g, DdNode * h, st_table * ghTable);
132static Conjuncts * CheckTablesCacheAndReturn (DdNode * node, DdNode * g, DdNode * h, st_table * ghTable, st_table * cacheTable);
133static Conjuncts * PickOnePair (DdNode * node, DdNode * g1, DdNode * h1, DdNode * g2, DdNode * h2, st_table * ghTable, st_table * cacheTable);
134static Conjuncts * CheckInTables (DdNode * node, DdNode * g1, DdNode * h1, DdNode * g2, DdNode * h2, st_table * ghTable, st_table * cacheTable, int * outOfMem);
135static Conjuncts * ZeroCase (DdManager * dd, DdNode * node, Conjuncts * factorsNv, st_table * ghTable, st_table * cacheTable, int switched);
136static Conjuncts * BuildConjuncts (DdManager * dd, DdNode * node, st_table * distanceTable, st_table * cacheTable, int approxDistance, int maxLocalRef, st_table * ghTable, st_table * mintermTable);
137static int cuddConjunctsAux (DdManager * dd, DdNode * f, DdNode ** c1, DdNode ** c2);
138
139/**AutomaticEnd***************************************************************/
140
141
142/*---------------------------------------------------------------------------*/
143/* Definition of exported functions */
144/*---------------------------------------------------------------------------*/
145
146
147/**Function********************************************************************
148
149 Synopsis [Performs two-way conjunctive decomposition of a BDD.]
150
151 Description [Performs two-way conjunctive decomposition of a
152 BDD. This procedure owes its name to the use of supersetting to
153 obtain an initial factor of the given function. Returns the number
154 of conjuncts produced, that is, 2 if successful; 1 if no meaningful
155 decomposition was found; 0 otherwise. The conjuncts produced by this
156 procedure tend to be imbalanced.]
157
158 SideEffects [The factors are returned in an array as side effects.
159 The array is allocated by this function. It is the caller's responsibility
160 to free it. On successful completion, the conjuncts are already
161 referenced. If the function returns 0, the array for the conjuncts is
162 not allocated. If the function returns 1, the only factor equals the
163 function to be decomposed.]
164
165 SeeAlso [Cudd_bddApproxDisjDecomp Cudd_bddIterConjDecomp
166 Cudd_bddGenConjDecomp Cudd_bddVarConjDecomp Cudd_RemapOverApprox
167 Cudd_bddSqueeze Cudd_bddLICompaction]
168
169******************************************************************************/
170int
171Cudd_bddApproxConjDecomp(
172 DdManager * dd /* manager */,
173 DdNode * f /* function to be decomposed */,
174 DdNode *** conjuncts /* address of the first factor */)
175{
176 DdNode *superset1, *superset2, *glocal, *hlocal;
177 int nvars = Cudd_SupportSize(dd,f);
178
179 /* Find a tentative first factor by overapproximation and minimization. */
180 superset1 = Cudd_RemapOverApprox(dd,f,nvars,0,1.0);
181 if (superset1 == NULL) return(0);
182 cuddRef(superset1);
183 superset2 = Cudd_bddSqueeze(dd,f,superset1);
184 if (superset2 == NULL) {
185 Cudd_RecursiveDeref(dd,superset1);
186 return(0);
187 }
188 cuddRef(superset2);
189 Cudd_RecursiveDeref(dd,superset1);
190
191 /* Compute the second factor by minimization. */
192 hlocal = Cudd_bddLICompaction(dd,f,superset2);
193 if (hlocal == NULL) {
194 Cudd_RecursiveDeref(dd,superset2);
195 return(0);
196 }
197 cuddRef(hlocal);
198
199 /* Refine the first factor by minimization. If h turns out to be f, this
200 ** step guarantees that g will be 1. */
201 glocal = Cudd_bddLICompaction(dd,superset2,hlocal);
202 if (glocal == NULL) {
203 Cudd_RecursiveDeref(dd,superset2);
204 Cudd_RecursiveDeref(dd,hlocal);
205 return(0);
206 }
207 cuddRef(glocal);
208 Cudd_RecursiveDeref(dd,superset2);
209
210 if (glocal != DD_ONE(dd)) {
211 if (hlocal != DD_ONE(dd)) {
212 *conjuncts = ALLOC(DdNode *,2);
213 if (*conjuncts == NULL) {
214 Cudd_RecursiveDeref(dd,glocal);
215 Cudd_RecursiveDeref(dd,hlocal);
216 dd->errorCode = CUDD_MEMORY_OUT;
217 return(0);
218 }
219 (*conjuncts)[0] = glocal;
220 (*conjuncts)[1] = hlocal;
221 return(2);
222 } else {
223 Cudd_RecursiveDeref(dd,hlocal);
224 *conjuncts = ALLOC(DdNode *,1);
225 if (*conjuncts == NULL) {
226 Cudd_RecursiveDeref(dd,glocal);
227 dd->errorCode = CUDD_MEMORY_OUT;
228 return(0);
229 }
230 (*conjuncts)[0] = glocal;
231 return(1);
232 }
233 } else {
234 Cudd_RecursiveDeref(dd,glocal);
235 *conjuncts = ALLOC(DdNode *,1);
236 if (*conjuncts == NULL) {
237 Cudd_RecursiveDeref(dd,hlocal);
238 dd->errorCode = CUDD_MEMORY_OUT;
239 return(0);
240 }
241 (*conjuncts)[0] = hlocal;
242 return(1);
243 }
244
245} /* end of Cudd_bddApproxConjDecomp */
246
247
248/**Function********************************************************************
249
250 Synopsis [Performs two-way disjunctive decomposition of a BDD.]
251
252 Description [Performs two-way disjunctive decomposition of a BDD.
253 Returns the number of disjuncts produced, that is, 2 if successful;
254 1 if no meaningful decomposition was found; 0 otherwise. The
255 disjuncts produced by this procedure tend to be imbalanced.]
256
257 SideEffects [The two disjuncts are returned in an array as side effects.
258 The array is allocated by this function. It is the caller's responsibility
259 to free it. On successful completion, the disjuncts are already
260 referenced. If the function returns 0, the array for the disjuncts is
261 not allocated. If the function returns 1, the only factor equals the
262 function to be decomposed.]
263
264 SeeAlso [Cudd_bddApproxConjDecomp Cudd_bddIterDisjDecomp
265 Cudd_bddGenDisjDecomp Cudd_bddVarDisjDecomp]
266
267******************************************************************************/
268int
269Cudd_bddApproxDisjDecomp(
270 DdManager * dd /* manager */,
271 DdNode * f /* function to be decomposed */,
272 DdNode *** disjuncts /* address of the array of the disjuncts */)
273{
274 int result, i;
275
276 result = Cudd_bddApproxConjDecomp(dd,Cudd_Not(f),disjuncts);
277 for (i = 0; i < result; i++) {
278 (*disjuncts)[i] = Cudd_Not((*disjuncts)[i]);
279 }
280 return(result);
281
282} /* end of Cudd_bddApproxDisjDecomp */
283
284
285/**Function********************************************************************
286
287 Synopsis [Performs two-way conjunctive decomposition of a BDD.]
288
289 Description [Performs two-way conjunctive decomposition of a
290 BDD. This procedure owes its name to the iterated use of
291 supersetting to obtain a factor of the given function. Returns the
292 number of conjuncts produced, that is, 2 if successful; 1 if no
293 meaningful decomposition was found; 0 otherwise. The conjuncts
294 produced by this procedure tend to be imbalanced.]
295
296 SideEffects [The factors are returned in an array as side effects.
297 The array is allocated by this function. It is the caller's responsibility
298 to free it. On successful completion, the conjuncts are already
299 referenced. If the function returns 0, the array for the conjuncts is
300 not allocated. If the function returns 1, the only factor equals the
301 function to be decomposed.]
302
303 SeeAlso [Cudd_bddIterDisjDecomp Cudd_bddApproxConjDecomp
304 Cudd_bddGenConjDecomp Cudd_bddVarConjDecomp Cudd_RemapOverApprox
305 Cudd_bddSqueeze Cudd_bddLICompaction]
306
307******************************************************************************/
308int
309Cudd_bddIterConjDecomp(
310 DdManager * dd /* manager */,
311 DdNode * f /* function to be decomposed */,
312 DdNode *** conjuncts /* address of the array of conjuncts */)
313{
314 DdNode *superset1, *superset2, *old[2], *res[2];
315 int sizeOld, sizeNew;
316 int nvars = Cudd_SupportSize(dd,f);
317
318 old[0] = DD_ONE(dd);
319 cuddRef(old[0]);
320 old[1] = f;
321 cuddRef(old[1]);
322 sizeOld = Cudd_SharingSize(old,2);
323
324 do {
325 /* Find a tentative first factor by overapproximation and
326 ** minimization. */
327 superset1 = Cudd_RemapOverApprox(dd,old[1],nvars,0,1.0);
328 if (superset1 == NULL) {
329 Cudd_RecursiveDeref(dd,old[0]);
330 Cudd_RecursiveDeref(dd,old[1]);
331 return(0);
332 }
333 cuddRef(superset1);
334 superset2 = Cudd_bddSqueeze(dd,old[1],superset1);
335 if (superset2 == NULL) {
336 Cudd_RecursiveDeref(dd,old[0]);
337 Cudd_RecursiveDeref(dd,old[1]);
338 Cudd_RecursiveDeref(dd,superset1);
339 return(0);
340 }
341 cuddRef(superset2);
342 Cudd_RecursiveDeref(dd,superset1);
343 res[0] = Cudd_bddAnd(dd,old[0],superset2);
344 if (res[0] == NULL) {
345 Cudd_RecursiveDeref(dd,superset2);
346 Cudd_RecursiveDeref(dd,old[0]);
347 Cudd_RecursiveDeref(dd,old[1]);
348 return(0);
349 }
350 cuddRef(res[0]);
351 Cudd_RecursiveDeref(dd,superset2);
352 if (res[0] == old[0]) {
353 Cudd_RecursiveDeref(dd,res[0]);
354 break; /* avoid infinite loop */
355 }
356
357 /* Compute the second factor by minimization. */
358 res[1] = Cudd_bddLICompaction(dd,old[1],res[0]);
359 if (res[1] == NULL) {
360 Cudd_RecursiveDeref(dd,old[0]);
361 Cudd_RecursiveDeref(dd,old[1]);
362 return(0);
363 }
364 cuddRef(res[1]);
365
366 sizeNew = Cudd_SharingSize(res,2);
367 if (sizeNew <= sizeOld) {
368 Cudd_RecursiveDeref(dd,old[0]);
369 old[0] = res[0];
370 Cudd_RecursiveDeref(dd,old[1]);
371 old[1] = res[1];
372 sizeOld = sizeNew;
373 } else {
374 Cudd_RecursiveDeref(dd,res[0]);
375 Cudd_RecursiveDeref(dd,res[1]);
376 break;
377 }
378
379 } while (1);
380
381 /* Refine the first factor by minimization. If h turns out to
382 ** be f, this step guarantees that g will be 1. */
383 superset1 = Cudd_bddLICompaction(dd,old[0],old[1]);
384 if (superset1 == NULL) {
385 Cudd_RecursiveDeref(dd,old[0]);
386 Cudd_RecursiveDeref(dd,old[1]);
387 return(0);
388 }
389 cuddRef(superset1);
390 Cudd_RecursiveDeref(dd,old[0]);
391 old[0] = superset1;
392
393 if (old[0] != DD_ONE(dd)) {
394 if (old[1] != DD_ONE(dd)) {
395 *conjuncts = ALLOC(DdNode *,2);
396 if (*conjuncts == NULL) {
397 Cudd_RecursiveDeref(dd,old[0]);
398 Cudd_RecursiveDeref(dd,old[1]);
399 dd->errorCode = CUDD_MEMORY_OUT;
400 return(0);
401 }
402 (*conjuncts)[0] = old[0];
403 (*conjuncts)[1] = old[1];
404 return(2);
405 } else {
406 Cudd_RecursiveDeref(dd,old[1]);
407 *conjuncts = ALLOC(DdNode *,1);
408 if (*conjuncts == NULL) {
409 Cudd_RecursiveDeref(dd,old[0]);
410 dd->errorCode = CUDD_MEMORY_OUT;
411 return(0);
412 }
413 (*conjuncts)[0] = old[0];
414 return(1);
415 }
416 } else {
417 Cudd_RecursiveDeref(dd,old[0]);
418 *conjuncts = ALLOC(DdNode *,1);
419 if (*conjuncts == NULL) {
420 Cudd_RecursiveDeref(dd,old[1]);
421 dd->errorCode = CUDD_MEMORY_OUT;
422 return(0);
423 }
424 (*conjuncts)[0] = old[1];
425 return(1);
426 }
427
428} /* end of Cudd_bddIterConjDecomp */
429
430
431/**Function********************************************************************
432
433 Synopsis [Performs two-way disjunctive decomposition of a BDD.]
434
435 Description [Performs two-way disjunctive decomposition of a BDD.
436 Returns the number of disjuncts produced, that is, 2 if successful;
437 1 if no meaningful decomposition was found; 0 otherwise. The
438 disjuncts produced by this procedure tend to be imbalanced.]
439
440 SideEffects [The two disjuncts are returned in an array as side effects.
441 The array is allocated by this function. It is the caller's responsibility
442 to free it. On successful completion, the disjuncts are already
443 referenced. If the function returns 0, the array for the disjuncts is
444 not allocated. If the function returns 1, the only factor equals the
445 function to be decomposed.]
446
447 SeeAlso [Cudd_bddIterConjDecomp Cudd_bddApproxDisjDecomp
448 Cudd_bddGenDisjDecomp Cudd_bddVarDisjDecomp]
449
450******************************************************************************/
451int
452Cudd_bddIterDisjDecomp(
453 DdManager * dd /* manager */,
454 DdNode * f /* function to be decomposed */,
455 DdNode *** disjuncts /* address of the array of the disjuncts */)
456{
457 int result, i;
458
459 result = Cudd_bddIterConjDecomp(dd,Cudd_Not(f),disjuncts);
460 for (i = 0; i < result; i++) {
461 (*disjuncts)[i] = Cudd_Not((*disjuncts)[i]);
462 }
463 return(result);
464
465} /* end of Cudd_bddIterDisjDecomp */
466
467
468/**Function********************************************************************
469
470 Synopsis [Performs two-way conjunctive decomposition of a BDD.]
471
472 Description [Performs two-way conjunctive decomposition of a
473 BDD. This procedure owes its name to the fact tht it generalizes the
474 decomposition based on the cofactors with respect to one
475 variable. Returns the number of conjuncts produced, that is, 2 if
476 successful; 1 if no meaningful decomposition was found; 0
477 otherwise. The conjuncts produced by this procedure tend to be
478 balanced.]
479
480 SideEffects [The two factors are returned in an array as side effects.
481 The array is allocated by this function. It is the caller's responsibility
482 to free it. On successful completion, the conjuncts are already
483 referenced. If the function returns 0, the array for the conjuncts is
484 not allocated. If the function returns 1, the only factor equals the
485 function to be decomposed.]
486
487 SeeAlso [Cudd_bddGenDisjDecomp Cudd_bddApproxConjDecomp
488 Cudd_bddIterConjDecomp Cudd_bddVarConjDecomp]
489
490******************************************************************************/
491int
492Cudd_bddGenConjDecomp(
493 DdManager * dd /* manager */,
494 DdNode * f /* function to be decomposed */,
495 DdNode *** conjuncts /* address of the array of conjuncts */)
496{
497 int result;
498 DdNode *glocal, *hlocal;
499
500 one = DD_ONE(dd);
501 zero = Cudd_Not(one);
502
503 do {
504 dd->reordered = 0;
505 result = cuddConjunctsAux(dd, f, &glocal, &hlocal);
506 } while (dd->reordered == 1);
507
508 if (result == 0) {
509 return(0);
510 }
511
512 if (glocal != one) {
513 if (hlocal != one) {
514 *conjuncts = ALLOC(DdNode *,2);
515 if (*conjuncts == NULL) {
516 Cudd_RecursiveDeref(dd,glocal);
517 Cudd_RecursiveDeref(dd,hlocal);
518 dd->errorCode = CUDD_MEMORY_OUT;
519 return(0);
520 }
521 (*conjuncts)[0] = glocal;
522 (*conjuncts)[1] = hlocal;
523 return(2);
524 } else {
525 Cudd_RecursiveDeref(dd,hlocal);
526 *conjuncts = ALLOC(DdNode *,1);
527 if (*conjuncts == NULL) {
528 Cudd_RecursiveDeref(dd,glocal);
529 dd->errorCode = CUDD_MEMORY_OUT;
530 return(0);
531 }
532 (*conjuncts)[0] = glocal;
533 return(1);
534 }
535 } else {
536 Cudd_RecursiveDeref(dd,glocal);
537 *conjuncts = ALLOC(DdNode *,1);
538 if (*conjuncts == NULL) {
539 Cudd_RecursiveDeref(dd,hlocal);
540 dd->errorCode = CUDD_MEMORY_OUT;
541 return(0);
542 }
543 (*conjuncts)[0] = hlocal;
544 return(1);
545 }
546
547} /* end of Cudd_bddGenConjDecomp */
548
549
550/**Function********************************************************************
551
552 Synopsis [Performs two-way disjunctive decomposition of a BDD.]
553
554 Description [Performs two-way disjunctive decomposition of a BDD.
555 Returns the number of disjuncts produced, that is, 2 if successful;
556 1 if no meaningful decomposition was found; 0 otherwise. The
557 disjuncts produced by this procedure tend to be balanced.]
558
559 SideEffects [The two disjuncts are returned in an array as side effects.
560 The array is allocated by this function. It is the caller's responsibility
561 to free it. On successful completion, the disjuncts are already
562 referenced. If the function returns 0, the array for the disjuncts is
563 not allocated. If the function returns 1, the only factor equals the
564 function to be decomposed.]
565
566 SeeAlso [Cudd_bddGenConjDecomp Cudd_bddApproxDisjDecomp
567 Cudd_bddIterDisjDecomp Cudd_bddVarDisjDecomp]
568
569******************************************************************************/
570int
571Cudd_bddGenDisjDecomp(
572 DdManager * dd /* manager */,
573 DdNode * f /* function to be decomposed */,
574 DdNode *** disjuncts /* address of the array of the disjuncts */)
575{
576 int result, i;
577
578 result = Cudd_bddGenConjDecomp(dd,Cudd_Not(f),disjuncts);
579 for (i = 0; i < result; i++) {
580 (*disjuncts)[i] = Cudd_Not((*disjuncts)[i]);
581 }
582 return(result);
583
584} /* end of Cudd_bddGenDisjDecomp */
585
586
587/**Function********************************************************************
588
589 Synopsis [Performs two-way conjunctive decomposition of a BDD.]
590
591 Description [Conjunctively decomposes one BDD according to a
592 variable. If <code>f</code> is the function of the BDD and
593 <code>x</code> is the variable, the decomposition is
594 <code>(f+x)(f+x')</code>. The variable is chosen so as to balance
595 the sizes of the two conjuncts and to keep them small. Returns the
596 number of conjuncts produced, that is, 2 if successful; 1 if no
597 meaningful decomposition was found; 0 otherwise.]
598
599 SideEffects [The two factors are returned in an array as side effects.
600 The array is allocated by this function. It is the caller's responsibility
601 to free it. On successful completion, the conjuncts are already
602 referenced. If the function returns 0, the array for the conjuncts is
603 not allocated. If the function returns 1, the only factor equals the
604 function to be decomposed.]
605
606 SeeAlso [Cudd_bddVarDisjDecomp Cudd_bddGenConjDecomp
607 Cudd_bddApproxConjDecomp Cudd_bddIterConjDecomp]
608
609*****************************************************************************/
610int
611Cudd_bddVarConjDecomp(
612 DdManager * dd /* manager */,
613 DdNode * f /* function to be decomposed */,
614 DdNode *** conjuncts /* address of the array of conjuncts */)
615{
616 int best;
617 int min;
618 DdNode *support, *scan, *var, *glocal, *hlocal;
619
620 /* Find best cofactoring variable. */
621 support = Cudd_Support(dd,f);
622 if (support == NULL) return(0);
623 if (Cudd_IsConstant(support)) {
624 *conjuncts = ALLOC(DdNode *,1);
625 if (*conjuncts == NULL) {
626 dd->errorCode = CUDD_MEMORY_OUT;
627 return(0);
628 }
629 (*conjuncts)[0] = f;
630 cuddRef((*conjuncts)[0]);
631 return(1);
632 }
633 cuddRef(support);
634 min = 1000000000;
635 best = -1;
636 scan = support;
637 while (!Cudd_IsConstant(scan)) {
638 int i = scan->index;
639 int est1 = Cudd_EstimateCofactor(dd,f,i,1);
640 int est0 = Cudd_EstimateCofactor(dd,f,i,0);
641 /* Minimize the size of the larger of the two cofactors. */
642 int est = (est1 > est0) ? est1 : est0;
643 if (est < min) {
644 min = est;
645 best = i;
646 }
647 scan = cuddT(scan);
648 }
649#ifdef DD_DEBUG
650 assert(best >= 0 && best < dd->size);
651#endif
652 Cudd_RecursiveDeref(dd,support);
653
654 var = Cudd_bddIthVar(dd,best);
655 glocal = Cudd_bddOr(dd,f,var);
656 if (glocal == NULL) {
657 return(0);
658 }
659 cuddRef(glocal);
660 hlocal = Cudd_bddOr(dd,f,Cudd_Not(var));
661 if (hlocal == NULL) {
662 Cudd_RecursiveDeref(dd,glocal);
663 return(0);
664 }
665 cuddRef(hlocal);
666
667 if (glocal != DD_ONE(dd)) {
668 if (hlocal != DD_ONE(dd)) {
669 *conjuncts = ALLOC(DdNode *,2);
670 if (*conjuncts == NULL) {
671 Cudd_RecursiveDeref(dd,glocal);
672 Cudd_RecursiveDeref(dd,hlocal);
673 dd->errorCode = CUDD_MEMORY_OUT;
674 return(0);
675 }
676 (*conjuncts)[0] = glocal;
677 (*conjuncts)[1] = hlocal;
678 return(2);
679 } else {
680 Cudd_RecursiveDeref(dd,hlocal);
681 *conjuncts = ALLOC(DdNode *,1);
682 if (*conjuncts == NULL) {
683 Cudd_RecursiveDeref(dd,glocal);
684 dd->errorCode = CUDD_MEMORY_OUT;
685 return(0);
686 }
687 (*conjuncts)[0] = glocal;
688 return(1);
689 }
690 } else {
691 Cudd_RecursiveDeref(dd,glocal);
692 *conjuncts = ALLOC(DdNode *,1);
693 if (*conjuncts == NULL) {
694 Cudd_RecursiveDeref(dd,hlocal);
695 dd->errorCode = CUDD_MEMORY_OUT;
696 return(0);
697 }
698 (*conjuncts)[0] = hlocal;
699 return(1);
700 }
701
702} /* end of Cudd_bddVarConjDecomp */
703
704
705/**Function********************************************************************
706
707 Synopsis [Performs two-way disjunctive decomposition of a BDD.]
708
709 Description [Performs two-way disjunctive decomposition of a BDD
710 according to a variable. If <code>f</code> is the function of the
711 BDD and <code>x</code> is the variable, the decomposition is
712 <code>f*x + f*x'</code>. The variable is chosen so as to balance
713 the sizes of the two disjuncts and to keep them small. Returns the
714 number of disjuncts produced, that is, 2 if successful; 1 if no
715 meaningful decomposition was found; 0 otherwise.]
716
717 SideEffects [The two disjuncts are returned in an array as side effects.
718 The array is allocated by this function. It is the caller's responsibility
719 to free it. On successful completion, the disjuncts are already
720 referenced. If the function returns 0, the array for the disjuncts is
721 not allocated. If the function returns 1, the only factor equals the
722 function to be decomposed.]
723
724 SeeAlso [Cudd_bddVarConjDecomp Cudd_bddApproxDisjDecomp
725 Cudd_bddIterDisjDecomp Cudd_bddGenDisjDecomp]
726
727******************************************************************************/
728int
729Cudd_bddVarDisjDecomp(
730 DdManager * dd /* manager */,
731 DdNode * f /* function to be decomposed */,
732 DdNode *** disjuncts /* address of the array of the disjuncts */)
733{
734 int result, i;
735
736 result = Cudd_bddVarConjDecomp(dd,Cudd_Not(f),disjuncts);
737 for (i = 0; i < result; i++) {
738 (*disjuncts)[i] = Cudd_Not((*disjuncts)[i]);
739 }
740 return(result);
741
742} /* end of Cudd_bddVarDisjDecomp */
743
744
745/*---------------------------------------------------------------------------*/
746/* Definition of internal functions */
747/*---------------------------------------------------------------------------*/
748
749/*---------------------------------------------------------------------------*/
750/* Definition of static functions */
751/*---------------------------------------------------------------------------*/
752
753
754/**Function********************************************************************
755
756 Synopsis [Get longest distance of node from constant.]
757
758 Description [Get longest distance of node from constant. Returns the
759 distance of the root from the constant if successful; CUDD_OUT_OF_MEM
760 otherwise.]
761
762 SideEffects [None]
763
764 SeeAlso []
765
766******************************************************************************/
767static NodeStat *
768CreateBotDist(
769 DdNode * node,
770 st_table * distanceTable)
771{
772 DdNode *N, *Nv, *Nnv;
773 int distance, distanceNv, distanceNnv;
774 NodeStat *nodeStat, *nodeStatNv, *nodeStatNnv;
775
776#if 0
777 if (Cudd_IsConstant(node)) {
778 return(0);
779 }
780#endif
781
782 /* Return the entry in the table if found. */
783 N = Cudd_Regular(node);
784 if (st_lookup(distanceTable, N, &nodeStat)) {
785 nodeStat->localRef++;
786 return(nodeStat);
787 }
788
789 Nv = cuddT(N);
790 Nnv = cuddE(N);
791 Nv = Cudd_NotCond(Nv, Cudd_IsComplement(node));
792 Nnv = Cudd_NotCond(Nnv, Cudd_IsComplement(node));
793
794 /* Recur on the children. */
795 nodeStatNv = CreateBotDist(Nv, distanceTable);
796 if (nodeStatNv == NULL) return(NULL);
797 distanceNv = nodeStatNv->distance;
798
799 nodeStatNnv = CreateBotDist(Nnv, distanceTable);
800 if (nodeStatNnv == NULL) return(NULL);
801 distanceNnv = nodeStatNnv->distance;
802 /* Store max distance from constant; note sometimes this distance
803 ** may be to 0.
804 */
805 distance = (distanceNv > distanceNnv) ? (distanceNv+1) : (distanceNnv + 1);
806
807 nodeStat = ALLOC(NodeStat, 1);
808 if (nodeStat == NULL) {
809 return(0);
810 }
811 nodeStat->distance = distance;
812 nodeStat->localRef = 1;
813
814 if (st_insert(distanceTable, (char *)N, (char *)nodeStat) ==
815 ST_OUT_OF_MEM) {
816 return(0);
817
818 }
819 return(nodeStat);
820
821} /* end of CreateBotDist */
822
823
824/**Function********************************************************************
825
826 Synopsis [Count the number of minterms of each node ina a BDD and
827 store it in a hash table.]
828
829 Description []
830
831 SideEffects [None]
832
833 SeeAlso []
834
835******************************************************************************/
836static double
837CountMinterms(
838 DdNode * node,
839 double max,
840 st_table * mintermTable,
841 FILE *fp)
842{
843 DdNode *N, *Nv, *Nnv;
844 double min, minNv, minNnv;
845 double *dummy;
846
847 N = Cudd_Regular(node);
848
849 if (cuddIsConstant(N)) {
850 if (node == zero) {
851 return(0);
852 } else {
853 return(max);
854 }
855 }
856
857 /* Return the entry in the table if found. */
858 if (st_lookup(mintermTable, node, &dummy)) {
859 min = *dummy;
860 return(min);
861 }
862
863 Nv = cuddT(N);
864 Nnv = cuddE(N);
865 Nv = Cudd_NotCond(Nv, Cudd_IsComplement(node));
866 Nnv = Cudd_NotCond(Nnv, Cudd_IsComplement(node));
867
868 /* Recur on the children. */
869 minNv = CountMinterms(Nv, max, mintermTable, fp);
870 if (minNv == -1.0) return(-1.0);
871 minNnv = CountMinterms(Nnv, max, mintermTable, fp);
872 if (minNnv == -1.0) return(-1.0);
873 min = minNv / 2.0 + minNnv / 2.0;
874 /* store
875 */
876
877 dummy = ALLOC(double, 1);
878 if (dummy == NULL) return(-1.0);
879 *dummy = min;
880 if (st_insert(mintermTable, (char *)node, (char *)dummy) == ST_OUT_OF_MEM) {
881 (void) fprintf(fp, "st table insert failed\n");
882 }
883 return(min);
884
885} /* end of CountMinterms */
886
887
888/**Function********************************************************************
889
890 Synopsis [Free factors structure]
891
892 Description []
893
894 SideEffects [None]
895
896 SeeAlso []
897
898******************************************************************************/
899static void
900ConjunctsFree(
901 DdManager * dd,
902 Conjuncts * factors)
903{
904 Cudd_RecursiveDeref(dd, factors->g);
905 Cudd_RecursiveDeref(dd, factors->h);
906 FREE(factors);
907 return;
908
909} /* end of ConjunctsFree */
910
911
912/**Function********************************************************************
913
914 Synopsis [Check whether the given pair is in the tables.]
915
916 Description [.Check whether the given pair is in the tables. gTable
917 and hTable are combined.
918 absence in both is indicated by 0,
919 presence in gTable is indicated by 1,
920 presence in hTable by 2 and
921 presence in both by 3.
922 The values returned by this function are PAIR_ST,
923 PAIR_CR, G_ST, G_CR, H_ST, H_CR, BOTH_G, BOTH_H, NONE.
924 PAIR_ST implies g in gTable and h in hTable
925 PAIR_CR implies g in hTable and h in gTable
926 G_ST implies g in gTable and h not in any table
927 G_CR implies g in hTable and h not in any table
928 H_ST implies h in hTable and g not in any table
929 H_CR implies h in gTable and g not in any table
930 BOTH_G implies both in gTable
931 BOTH_H implies both in hTable
932 NONE implies none in table; ]
933
934 SideEffects []
935
936 SeeAlso [CheckTablesCacheAndReturn CheckInTables]
937
938******************************************************************************/
939static int
940PairInTables(
941 DdNode * g,
942 DdNode * h,
943 st_table * ghTable)
944{
945 int valueG, valueH, gPresent, hPresent;
946
947 valueG = valueH = gPresent = hPresent = 0;
948
949 gPresent = st_lookup_int(ghTable, (char *)Cudd_Regular(g), &valueG);
950 hPresent = st_lookup_int(ghTable, (char *)Cudd_Regular(h), &valueH);
951
952 if (!gPresent && !hPresent) return(NONE);
953
954 if (!hPresent) {
955 if (valueG & 1) return(G_ST);
956 if (valueG & 2) return(G_CR);
957 }
958 if (!gPresent) {
959 if (valueH & 1) return(H_CR);
960 if (valueH & 2) return(H_ST);
961 }
962 /* both in tables */
963 if ((valueG & 1) && (valueH & 2)) return(PAIR_ST);
964 if ((valueG & 2) && (valueH & 1)) return(PAIR_CR);
965
966 if (valueG & 1) {
967 return(BOTH_G);
968 } else {
969 return(BOTH_H);
970 }
971
972} /* end of PairInTables */
973
974
975/**Function********************************************************************
976
977 Synopsis [Check the tables for the existence of pair and return one
978 combination, cache the result.]
979
980 Description [Check the tables for the existence of pair and return
981 one combination, cache the result. The assumption is that one of the
982 conjuncts is already in the tables.]
983
984 SideEffects [g and h referenced for the cache]
985
986 SeeAlso [ZeroCase]
987
988******************************************************************************/
989static Conjuncts *
990CheckTablesCacheAndReturn(
991 DdNode * node,
992 DdNode * g,
993 DdNode * h,
994 st_table * ghTable,
995 st_table * cacheTable)
996{
997 int pairValue;
998 int value;
999 Conjuncts *factors;
1000
1001 value = 0;
1002 /* check tables */
1003 pairValue = PairInTables(g, h, ghTable);
1004 assert(pairValue != NONE);
1005 /* if both dont exist in table, we know one exists(either g or h).
1006 * Therefore store the other and proceed
1007 */
1008 factors = ALLOC(Conjuncts, 1);
1009 if (factors == NULL) return(NULL);
1010 if ((pairValue == BOTH_H) || (pairValue == H_ST)) {
1011 if (g != one) {
1012 value = 0;
1013 if (st_lookup_int(ghTable, (char *)Cudd_Regular(g), &value)) {
1014 value |= 1;
1015 } else {
1016 value = 1;
1017 }
1018 if (st_insert(ghTable, (char *)Cudd_Regular(g),
1019 (char *)(long)value) == ST_OUT_OF_MEM) {
1020 return(NULL);
1021 }
1022 }
1023 factors->g = g;
1024 factors->h = h;
1025 } else if ((pairValue == BOTH_G) || (pairValue == G_ST)) {
1026 if (h != one) {
1027 value = 0;
1028 if (st_lookup_int(ghTable, (char *)Cudd_Regular(h), &value)) {
1029 value |= 2;
1030 } else {
1031 value = 2;
1032 }
1033 if (st_insert(ghTable, (char *)Cudd_Regular(h),
1034 (char *)(long)value) == ST_OUT_OF_MEM) {
1035 return(NULL);
1036 }
1037 }
1038 factors->g = g;
1039 factors->h = h;
1040 } else if (pairValue == H_CR) {
1041 if (g != one) {
1042 value = 2;
1043 if (st_insert(ghTable, (char *)Cudd_Regular(g),
1044 (char *)(long)value) == ST_OUT_OF_MEM) {
1045 return(NULL);
1046 }
1047 }
1048 factors->g = h;
1049 factors->h = g;
1050 } else if (pairValue == G_CR) {
1051 if (h != one) {
1052 value = 1;
1053 if (st_insert(ghTable, (char *)Cudd_Regular(h),
1054 (char *)(long)value) == ST_OUT_OF_MEM) {
1055 return(NULL);
1056 }
1057 }
1058 factors->g = h;
1059 factors->h = g;
1060 } else if (pairValue == PAIR_CR) {
1061 /* pair exists in table */
1062 factors->g = h;
1063 factors->h = g;
1064 } else if (pairValue == PAIR_ST) {
1065 factors->g = g;
1066 factors->h = h;
1067 }
1068
1069 /* cache the result for this node */
1070 if (st_insert(cacheTable, (char *)node, (char *)factors) == ST_OUT_OF_MEM) {
1071 FREE(factors);
1072 return(NULL);
1073 }
1074
1075 return(factors);
1076
1077} /* end of CheckTablesCacheAndReturn */
1078
1079/**Function********************************************************************
1080
1081 Synopsis [Check the tables for the existence of pair and return one
1082 combination, store in cache.]
1083
1084 Description [Check the tables for the existence of pair and return
1085 one combination, store in cache. The pair that has more pointers to
1086 it is picked. An approximation of the number of local pointers is
1087 made by taking the reference count of the pairs sent. ]
1088
1089 SideEffects []
1090
1091 SeeAlso [ZeroCase BuildConjuncts]
1092
1093******************************************************************************/
1094static Conjuncts *
1095PickOnePair(
1096 DdNode * node,
1097 DdNode * g1,
1098 DdNode * h1,
1099 DdNode * g2,
1100 DdNode * h2,
1101 st_table * ghTable,
1102 st_table * cacheTable)
1103{
1104 int value;
1105 Conjuncts *factors;
1106 int oneRef, twoRef;
1107
1108 factors = ALLOC(Conjuncts, 1);
1109 if (factors == NULL) return(NULL);
1110
1111 /* count the number of pointers to pair 2 */
1112 if (h2 == one) {
1113 twoRef = (Cudd_Regular(g2))->ref;
1114 } else if (g2 == one) {
1115 twoRef = (Cudd_Regular(h2))->ref;
1116 } else {
1117 twoRef = ((Cudd_Regular(g2))->ref + (Cudd_Regular(h2))->ref)/2;
1118 }
1119
1120 /* count the number of pointers to pair 1 */
1121 if (h1 == one) {
1122 oneRef = (Cudd_Regular(g1))->ref;
1123 } else if (g1 == one) {
1124 oneRef = (Cudd_Regular(h1))->ref;
1125 } else {
1126 oneRef = ((Cudd_Regular(g1))->ref + (Cudd_Regular(h1))->ref)/2;
1127 }
1128
1129 /* pick the pair with higher reference count */
1130 if (oneRef >= twoRef) {
1131 factors->g = g1;
1132 factors->h = h1;
1133 } else {
1134 factors->g = g2;
1135 factors->h = h2;
1136 }
1137
1138 /*
1139 * Store computed factors in respective tables to encourage
1140 * recombination.
1141 */
1142 if (factors->g != one) {
1143 /* insert g in htable */
1144 value = 0;
1145 if (st_lookup_int(ghTable, (char *)Cudd_Regular(factors->g), &value)) {
1146 if (value == 2) {
1147 value |= 1;
1148 if (st_insert(ghTable, (char *)Cudd_Regular(factors->g),
1149 (char *)(long)value) == ST_OUT_OF_MEM) {
1150 FREE(factors);
1151 return(NULL);
1152 }
1153 }
1154 } else {
1155 value = 1;
1156 if (st_insert(ghTable, (char *)Cudd_Regular(factors->g),
1157 (char *)(long)value) == ST_OUT_OF_MEM) {
1158 FREE(factors);
1159 return(NULL);
1160 }
1161 }
1162 }
1163
1164 if (factors->h != one) {
1165 /* insert h in htable */
1166 value = 0;
1167 if (st_lookup_int(ghTable, (char *)Cudd_Regular(factors->h), &value)) {
1168 if (value == 1) {
1169 value |= 2;
1170 if (st_insert(ghTable, (char *)Cudd_Regular(factors->h),
1171 (char *)(long)value) == ST_OUT_OF_MEM) {
1172 FREE(factors);
1173 return(NULL);
1174 }
1175 }
1176 } else {
1177 value = 2;
1178 if (st_insert(ghTable, (char *)Cudd_Regular(factors->h),
1179 (char *)(long)value) == ST_OUT_OF_MEM) {
1180 FREE(factors);
1181 return(NULL);
1182 }
1183 }
1184 }
1185
1186 /* Store factors in cache table for later use. */
1187 if (st_insert(cacheTable, (char *)node, (char *)factors) ==
1188 ST_OUT_OF_MEM) {
1189 FREE(factors);
1190 return(NULL);
1191 }
1192
1193 return(factors);
1194
1195} /* end of PickOnePair */
1196
1197
1198/**Function********************************************************************
1199
1200 Synopsis [Check if the two pairs exist in the table, If any of the
1201 conjuncts do exist, store in the cache and return the corresponding pair.]
1202
1203 Description [Check if the two pairs exist in the table. If any of
1204 the conjuncts do exist, store in the cache and return the
1205 corresponding pair.]
1206
1207 SideEffects []
1208
1209 SeeAlso [ZeroCase BuildConjuncts]
1210
1211******************************************************************************/
1212static Conjuncts *
1213CheckInTables(
1214 DdNode * node,
1215 DdNode * g1,
1216 DdNode * h1,
1217 DdNode * g2,
1218 DdNode * h2,
1219 st_table * ghTable,
1220 st_table * cacheTable,
1221 int * outOfMem)
1222{
1223 int pairValue1, pairValue2;
1224 Conjuncts *factors;
1225 int value;
1226
1227 *outOfMem = 0;
1228
1229 /* check existence of pair in table */
1230 pairValue1 = PairInTables(g1, h1, ghTable);
1231 pairValue2 = PairInTables(g2, h2, ghTable);
1232
1233 /* if none of the 4 exist in the gh tables, return NULL */
1234 if ((pairValue1 == NONE) && (pairValue2 == NONE)) {
1235 return NULL;
1236 }
1237
1238 factors = ALLOC(Conjuncts, 1);
1239 if (factors == NULL) {
1240 *outOfMem = 1;
1241 return NULL;
1242 }
1243
1244 /* pairs that already exist in the table get preference. */
1245 if (pairValue1 == PAIR_ST) {
1246 factors->g = g1;
1247 factors->h = h1;
1248 } else if (pairValue2 == PAIR_ST) {
1249 factors->g = g2;
1250 factors->h = h2;
1251 } else if (pairValue1 == PAIR_CR) {
1252 factors->g = h1;
1253 factors->h = g1;
1254 } else if (pairValue2 == PAIR_CR) {
1255 factors->g = h2;
1256 factors->h = g2;
1257 } else if (pairValue1 == G_ST) {
1258 /* g exists in the table, h is not found in either table */
1259 factors->g = g1;
1260 factors->h = h1;
1261 if (h1 != one) {
1262 value = 2;
1263 if (st_insert(ghTable, (char *)Cudd_Regular(h1),
1264 (char *)(long)value) == ST_OUT_OF_MEM) {
1265 *outOfMem = 1;
1266 FREE(factors);
1267 return(NULL);
1268 }
1269 }
1270 } else if (pairValue1 == BOTH_G) {
1271 /* g and h are found in the g table */
1272 factors->g = g1;
1273 factors->h = h1;
1274 if (h1 != one) {
1275 value = 3;
1276 if (st_insert(ghTable, (char *)Cudd_Regular(h1),
1277 (char *)(long)value) == ST_OUT_OF_MEM) {
1278 *outOfMem = 1;
1279 FREE(factors);
1280 return(NULL);
1281 }
1282 }
1283 } else if (pairValue1 == H_ST) {
1284 /* h exists in the table, g is not found in either table */
1285 factors->g = g1;
1286 factors->h = h1;
1287 if (g1 != one) {
1288 value = 1;
1289 if (st_insert(ghTable, (char *)Cudd_Regular(g1),
1290 (char *)(long)value) == ST_OUT_OF_MEM) {
1291 *outOfMem = 1;
1292 FREE(factors);
1293 return(NULL);
1294 }
1295 }
1296 } else if (pairValue1 == BOTH_H) {
1297 /* g and h are found in the h table */
1298 factors->g = g1;
1299 factors->h = h1;
1300 if (g1 != one) {
1301 value = 3;
1302 if (st_insert(ghTable, (char *)Cudd_Regular(g1),
1303 (char *)(long)value) == ST_OUT_OF_MEM) {
1304 *outOfMem = 1;
1305 FREE(factors);
1306 return(NULL);
1307 }
1308 }
1309 } else if (pairValue2 == G_ST) {
1310 /* g exists in the table, h is not found in either table */
1311 factors->g = g2;
1312 factors->h = h2;
1313 if (h2 != one) {
1314 value = 2;
1315 if (st_insert(ghTable, (char *)Cudd_Regular(h2),
1316 (char *)(long)value) == ST_OUT_OF_MEM) {
1317 *outOfMem = 1;
1318 FREE(factors);
1319 return(NULL);
1320 }
1321 }
1322 } else if (pairValue2 == BOTH_G) {
1323 /* g and h are found in the g table */
1324 factors->g = g2;
1325 factors->h = h2;
1326 if (h2 != one) {
1327 value = 3;
1328 if (st_insert(ghTable, (char *)Cudd_Regular(h2),
1329 (char *)(long)value) == ST_OUT_OF_MEM) {
1330 *outOfMem = 1;
1331 FREE(factors);
1332 return(NULL);
1333 }
1334 }
1335 } else if (pairValue2 == H_ST) {
1336 /* h exists in the table, g is not found in either table */
1337 factors->g = g2;
1338 factors->h = h2;
1339 if (g2 != one) {
1340 value = 1;
1341 if (st_insert(ghTable, (char *)Cudd_Regular(g2),
1342 (char *)(long)value) == ST_OUT_OF_MEM) {
1343 *outOfMem = 1;
1344 FREE(factors);
1345 return(NULL);
1346 }
1347 }
1348 } else if (pairValue2 == BOTH_H) {
1349 /* g and h are found in the h table */
1350 factors->g = g2;
1351 factors->h = h2;
1352 if (g2 != one) {
1353 value = 3;
1354 if (st_insert(ghTable, (char *)Cudd_Regular(g2),
1355 (char *)(long)value) == ST_OUT_OF_MEM) {
1356 *outOfMem = 1;
1357 FREE(factors);
1358 return(NULL);
1359 }
1360 }
1361 } else if (pairValue1 == G_CR) {
1362 /* g found in h table and h in none */
1363 factors->g = h1;
1364 factors->h = g1;
1365 if (h1 != one) {
1366 value = 1;
1367 if (st_insert(ghTable, (char *)Cudd_Regular(h1),
1368 (char *)(long)value) == ST_OUT_OF_MEM) {
1369 *outOfMem = 1;
1370 FREE(factors);
1371 return(NULL);
1372 }
1373 }
1374 } else if (pairValue1 == H_CR) {
1375 /* h found in g table and g in none */
1376 factors->g = h1;
1377 factors->h = g1;
1378 if (g1 != one) {
1379 value = 2;
1380 if (st_insert(ghTable, (char *)Cudd_Regular(g1),
1381 (char *)(long)value) == ST_OUT_OF_MEM) {
1382 *outOfMem = 1;
1383 FREE(factors);
1384 return(NULL);
1385 }
1386 }
1387 } else if (pairValue2 == G_CR) {
1388 /* g found in h table and h in none */
1389 factors->g = h2;
1390 factors->h = g2;
1391 if (h2 != one) {
1392 value = 1;
1393 if (st_insert(ghTable, (char *)Cudd_Regular(h2),
1394 (char *)(long)value) == ST_OUT_OF_MEM) {
1395 *outOfMem = 1;
1396 FREE(factors);
1397 return(NULL);
1398 }
1399 }
1400 } else if (pairValue2 == H_CR) {
1401 /* h found in g table and g in none */
1402 factors->g = h2;
1403 factors->h = g2;
1404 if (g2 != one) {
1405 value = 2;
1406 if (st_insert(ghTable, (char *)Cudd_Regular(g2),
1407 (char *)(long)value) == ST_OUT_OF_MEM) {
1408 *outOfMem = 1;
1409 FREE(factors);
1410 return(NULL);
1411 }
1412 }
1413 }
1414
1415 /* Store factors in cache table for later use. */
1416 if (st_insert(cacheTable, (char *)node, (char *)factors) ==
1417 ST_OUT_OF_MEM) {
1418 *outOfMem = 1;
1419 FREE(factors);
1420 return(NULL);
1421 }
1422 return factors;
1423} /* end of CheckInTables */
1424
1425
1426
1427/**Function********************************************************************
1428
1429 Synopsis [If one child is zero, do explicitly what Restrict does or better]
1430
1431 Description [If one child is zero, do explicitly what Restrict does or better.
1432 First separate a variable and its child in the base case. In case of a cube
1433 times a function, separate the cube and function. As a last resort, look in
1434 tables.]
1435
1436 SideEffects [Frees the BDDs in factorsNv. factorsNv itself is not freed
1437 because it is freed above.]
1438
1439 SeeAlso [BuildConjuncts]
1440
1441******************************************************************************/
1442static Conjuncts *
1443ZeroCase(
1444 DdManager * dd,
1445 DdNode * node,
1446 Conjuncts * factorsNv,
1447 st_table * ghTable,
1448 st_table * cacheTable,
1449 int switched)
1450{
1451 int topid;
1452 DdNode *g, *h, *g1, *g2, *h1, *h2, *x, *N, *G, *H, *Gv, *Gnv;
1453 DdNode *Hv, *Hnv;
1454 int value;
1455 int outOfMem;
1456 Conjuncts *factors;
1457
1458 /* get var at this node */
1459 N = Cudd_Regular(node);
1460 topid = N->index;
1461 x = dd->vars[topid];
1462 x = (switched) ? Cudd_Not(x): x;
1463 cuddRef(x);
1464
1465 /* Seprate variable and child */
1466 if (factorsNv->g == one) {
1467 Cudd_RecursiveDeref(dd, factorsNv->g);
1468 factors = ALLOC(Conjuncts, 1);
1469 if (factors == NULL) {
1470 dd->errorCode = CUDD_MEMORY_OUT;
1471 Cudd_RecursiveDeref(dd, factorsNv->h);
1472 Cudd_RecursiveDeref(dd, x);
1473 return(NULL);
1474 }
1475 factors->g = x;
1476 factors->h = factorsNv->h;
1477 /* cache the result*/
1478 if (st_insert(cacheTable, (char *)node, (char *)factors) == ST_OUT_OF_MEM) {
1479 dd->errorCode = CUDD_MEMORY_OUT;
1480 Cudd_RecursiveDeref(dd, factorsNv->h);
1481 Cudd_RecursiveDeref(dd, x);
1482 FREE(factors);
1483 return NULL;
1484 }
1485
1486 /* store x in g table, the other node is already in the table */
1487 if (st_lookup_int(ghTable, (char *)Cudd_Regular(x), &value)) {
1488 value |= 1;
1489 } else {
1490 value = 1;
1491 }
1492 if (st_insert(ghTable, (char *)Cudd_Regular(x), (char *)(long)value) == ST_OUT_OF_MEM) {
1493 dd->errorCode = CUDD_MEMORY_OUT;
1494 return NULL;
1495 }
1496 return(factors);
1497 }
1498
1499 /* Seprate variable and child */
1500 if (factorsNv->h == one) {
1501 Cudd_RecursiveDeref(dd, factorsNv->h);
1502 factors = ALLOC(Conjuncts, 1);
1503 if (factors == NULL) {
1504 dd->errorCode = CUDD_MEMORY_OUT;
1505 Cudd_RecursiveDeref(dd, factorsNv->g);
1506 Cudd_RecursiveDeref(dd, x);
1507 return(NULL);
1508 }
1509 factors->g = factorsNv->g;
1510 factors->h = x;
1511 /* cache the result. */
1512 if (st_insert(cacheTable, (char *)node, (char *)factors) == ST_OUT_OF_MEM) {
1513 dd->errorCode = CUDD_MEMORY_OUT;
1514 Cudd_RecursiveDeref(dd, factorsNv->g);
1515 Cudd_RecursiveDeref(dd, x);
1516 FREE(factors);
1517 return(NULL);
1518 }
1519 /* store x in h table, the other node is already in the table */
1520 if (st_lookup_int(ghTable, (char *)Cudd_Regular(x), &value)) {
1521 value |= 2;
1522 } else {
1523 value = 2;
1524 }
1525 if (st_insert(ghTable, (char *)Cudd_Regular(x), (char *)(long)value) == ST_OUT_OF_MEM) {
1526 dd->errorCode = CUDD_MEMORY_OUT;
1527 return NULL;
1528 }
1529 return(factors);
1530 }
1531
1532 G = Cudd_Regular(factorsNv->g);
1533 Gv = cuddT(G);
1534 Gnv = cuddE(G);
1535 Gv = Cudd_NotCond(Gv, Cudd_IsComplement(node));
1536 Gnv = Cudd_NotCond(Gnv, Cudd_IsComplement(node));
1537 /* if the child below is a variable */
1538 if ((Gv == zero) || (Gnv == zero)) {
1539 h = factorsNv->h;
1540 g = cuddBddAndRecur(dd, x, factorsNv->g);
1541 if (g != NULL) cuddRef(g);
1542 Cudd_RecursiveDeref(dd, factorsNv->g);
1543 Cudd_RecursiveDeref(dd, x);
1544 if (g == NULL) {
1545 Cudd_RecursiveDeref(dd, factorsNv->h);
1546 return NULL;
1547 }
1548 /* CheckTablesCacheAndReturn responsible for allocating
1549 * factors structure., g,h referenced for cache store the
1550 */
1551 factors = CheckTablesCacheAndReturn(node,
1552 g,
1553 h,
1554 ghTable,
1555 cacheTable);
1556 if (factors == NULL) {
1557 dd->errorCode = CUDD_MEMORY_OUT;
1558 Cudd_RecursiveDeref(dd, g);
1559 Cudd_RecursiveDeref(dd, h);
1560 }
1561 return(factors);
1562 }
1563
1564 H = Cudd_Regular(factorsNv->h);
1565 Hv = cuddT(H);
1566 Hnv = cuddE(H);
1567 Hv = Cudd_NotCond(Hv, Cudd_IsComplement(node));
1568 Hnv = Cudd_NotCond(Hnv, Cudd_IsComplement(node));
1569 /* if the child below is a variable */
1570 if ((Hv == zero) || (Hnv == zero)) {
1571 g = factorsNv->g;
1572 h = cuddBddAndRecur(dd, x, factorsNv->h);
1573 if (h!= NULL) cuddRef(h);
1574 Cudd_RecursiveDeref(dd, factorsNv->h);
1575 Cudd_RecursiveDeref(dd, x);
1576 if (h == NULL) {
1577 Cudd_RecursiveDeref(dd, factorsNv->g);
1578 return NULL;
1579 }
1580 /* CheckTablesCacheAndReturn responsible for allocating
1581 * factors structure.g,h referenced for table store
1582 */
1583 factors = CheckTablesCacheAndReturn(node,
1584 g,
1585 h,
1586 ghTable,
1587 cacheTable);
1588 if (factors == NULL) {
1589 dd->errorCode = CUDD_MEMORY_OUT;
1590 Cudd_RecursiveDeref(dd, g);
1591 Cudd_RecursiveDeref(dd, h);
1592 }
1593 return(factors);
1594 }
1595
1596 /* build g1 = x*g; h1 = h */
1597 /* build g2 = g; h2 = x*h */
1598 Cudd_RecursiveDeref(dd, x);
1599 h1 = factorsNv->h;
1600 g1 = cuddBddAndRecur(dd, x, factorsNv->g);
1601 if (g1 != NULL) cuddRef(g1);
1602 if (g1 == NULL) {
1603 Cudd_RecursiveDeref(dd, factorsNv->g);
1604 Cudd_RecursiveDeref(dd, factorsNv->h);
1605 return NULL;
1606 }
1607
1608 g2 = factorsNv->g;
1609 h2 = cuddBddAndRecur(dd, x, factorsNv->h);
1610 if (h2 != NULL) cuddRef(h2);
1611 if (h2 == NULL) {
1612 Cudd_RecursiveDeref(dd, factorsNv->h);
1613 Cudd_RecursiveDeref(dd, factorsNv->g);
1614 return NULL;
1615 }
1616
1617 /* check whether any pair is in tables */
1618 factors = CheckInTables(node, g1, h1, g2, h2, ghTable, cacheTable, &outOfMem);
1619 if (outOfMem) {
1620 dd->errorCode = CUDD_MEMORY_OUT;
1621 Cudd_RecursiveDeref(dd, g1);
1622 Cudd_RecursiveDeref(dd, h1);
1623 Cudd_RecursiveDeref(dd, g2);
1624 Cudd_RecursiveDeref(dd, h2);
1625 return NULL;
1626 }
1627 if (factors != NULL) {
1628 if ((factors->g == g1) || (factors->g == h1)) {
1629 Cudd_RecursiveDeref(dd, g2);
1630 Cudd_RecursiveDeref(dd, h2);
1631 } else {
1632 Cudd_RecursiveDeref(dd, g1);
1633 Cudd_RecursiveDeref(dd, h1);
1634 }
1635 return factors;
1636 }
1637
1638 /* check for each pair in tables and choose one */
1639 factors = PickOnePair(node,g1, h1, g2, h2, ghTable, cacheTable);
1640 if (factors == NULL) {
1641 dd->errorCode = CUDD_MEMORY_OUT;
1642 Cudd_RecursiveDeref(dd, g1);
1643 Cudd_RecursiveDeref(dd, h1);
1644 Cudd_RecursiveDeref(dd, g2);
1645 Cudd_RecursiveDeref(dd, h2);
1646 } else {
1647 /* now free what was created and not used */
1648 if ((factors->g == g1) || (factors->g == h1)) {
1649 Cudd_RecursiveDeref(dd, g2);
1650 Cudd_RecursiveDeref(dd, h2);
1651 } else {
1652 Cudd_RecursiveDeref(dd, g1);
1653 Cudd_RecursiveDeref(dd, h1);
1654 }
1655 }
1656
1657 return(factors);
1658} /* end of ZeroCase */
1659
1660
1661/**Function********************************************************************
1662
1663 Synopsis [Builds the conjuncts recursively, bottom up.]
1664
1665 Description [Builds the conjuncts recursively, bottom up. Constants
1666 are returned as (f, f). The cache is checked for previously computed
1667 result. The decomposition points are determined by the local
1668 reference count of this node and the longest distance from the
1669 constant. At the decomposition point, the factors returned are (f,
1670 1). Recur on the two children. The order is determined by the
1671 heavier branch. Combine the factors of the two children and pick the
1672 one that already occurs in the gh table. Occurence in g is indicated
1673 by value 1, occurence in h by 2, occurence in both 3.]
1674
1675 SideEffects []
1676
1677 SeeAlso [cuddConjunctsAux]
1678
1679******************************************************************************/
1680static Conjuncts *
1681BuildConjuncts(
1682 DdManager * dd,
1683 DdNode * node,
1684 st_table * distanceTable,
1685 st_table * cacheTable,
1686 int approxDistance,
1687 int maxLocalRef,
1688 st_table * ghTable,
1689 st_table * mintermTable)
1690{
1691 int topid, distance;
1692 Conjuncts *factorsNv, *factorsNnv, *factors;
1693 Conjuncts *dummy;
1694 DdNode *N, *Nv, *Nnv, *temp, *g1, *g2, *h1, *h2, *topv;
1695 double minNv = 0.0, minNnv = 0.0;
1696 double *doubleDummy;
1697 int switched =0;
1698 int outOfMem;
1699 int freeNv = 0, freeNnv = 0, freeTemp;
1700 NodeStat *nodeStat;
1701 int value;
1702
1703 /* if f is constant, return (f,f) */
1704 if (Cudd_IsConstant(node)) {
1705 factors = ALLOC(Conjuncts, 1);
1706 if (factors == NULL) {
1707 dd->errorCode = CUDD_MEMORY_OUT;
1708 return(NULL);
1709 }
1710 factors->g = node;
1711 factors->h = node;
1712 return(FactorsComplement(factors));
1713 }
1714
1715 /* If result (a pair of conjuncts) in cache, return the factors. */
1716 if (st_lookup(cacheTable, node, &dummy)) {
1717 factors = dummy;
1718 return(factors);
1719 }
1720
1721 /* check distance and local reference count of this node */
1722 N = Cudd_Regular(node);
1723 if (!st_lookup(distanceTable, N, &nodeStat)) {
1724 (void) fprintf(dd->err, "Not in table, Something wrong\n");
1725 dd->errorCode = CUDD_INTERNAL_ERROR;
1726 return(NULL);
1727 }
1728 distance = nodeStat->distance;
1729
1730 /* at or below decomposition point, return (f, 1) */
1731 if (((nodeStat->localRef > maxLocalRef*2/3) &&
1732 (distance < approxDistance*2/3)) ||
1733 (distance <= approxDistance/4)) {
1734 factors = ALLOC(Conjuncts, 1);
1735 if (factors == NULL) {
1736 dd->errorCode = CUDD_MEMORY_OUT;
1737 return(NULL);
1738 }
1739 /* alternate assigning (f,1) */
1740 value = 0;
1741 if (st_lookup_int(ghTable, (char *)Cudd_Regular(node), &value)) {
1742 if (value == 3) {
1743 if (!lastTimeG) {
1744 factors->g = node;
1745 factors->h = one;
1746 lastTimeG = 1;
1747 } else {
1748 factors->g = one;
1749 factors->h = node;
1750 lastTimeG = 0;
1751 }
1752 } else if (value == 1) {
1753 factors->g = node;
1754 factors->h = one;
1755 } else {
1756 factors->g = one;
1757 factors->h = node;
1758 }
1759 } else if (!lastTimeG) {
1760 factors->g = node;
1761 factors->h = one;
1762 lastTimeG = 1;
1763 value = 1;
1764 if (st_insert(ghTable, (char *)Cudd_Regular(node), (char *)(long)value) == ST_OUT_OF_MEM) {
1765 dd->errorCode = CUDD_MEMORY_OUT;
1766 FREE(factors);
1767 return NULL;
1768 }
1769 } else {
1770 factors->g = one;
1771 factors->h = node;
1772 lastTimeG = 0;
1773 value = 2;
1774 if (st_insert(ghTable, (char *)Cudd_Regular(node), (char *)(long)value) == ST_OUT_OF_MEM) {
1775 dd->errorCode = CUDD_MEMORY_OUT;
1776 FREE(factors);
1777 return NULL;
1778 }
1779 }
1780 return(FactorsComplement(factors));
1781 }
1782
1783 /* get the children and recur */
1784 Nv = cuddT(N);
1785 Nnv = cuddE(N);
1786 Nv = Cudd_NotCond(Nv, Cudd_IsComplement(node));
1787 Nnv = Cudd_NotCond(Nnv, Cudd_IsComplement(node));
1788
1789 /* Choose which subproblem to solve first based on the number of
1790 * minterms. We go first where there are more minterms.
1791 */
1792 if (!Cudd_IsConstant(Nv)) {
1793 if (!st_lookup(mintermTable, Nv, &doubleDummy)) {
1794 (void) fprintf(dd->err, "Not in table: Something wrong\n");
1795 dd->errorCode = CUDD_INTERNAL_ERROR;
1796 return(NULL);
1797 }
1798 minNv = *doubleDummy;
1799 }
1800
1801 if (!Cudd_IsConstant(Nnv)) {
1802 if (!st_lookup(mintermTable, Nnv, &doubleDummy)) {
1803 (void) fprintf(dd->err, "Not in table: Something wrong\n");
1804 dd->errorCode = CUDD_INTERNAL_ERROR;
1805 return(NULL);
1806 }
1807 minNnv = *doubleDummy;
1808 }
1809
1810 if (minNv < minNnv) {
1811 temp = Nv;
1812 Nv = Nnv;
1813 Nnv = temp;
1814 switched = 1;
1815 }
1816
1817 /* build gt, ht recursively */
1818 if (Nv != zero) {
1819 factorsNv = BuildConjuncts(dd, Nv, distanceTable,
1820 cacheTable, approxDistance, maxLocalRef,
1821 ghTable, mintermTable);
1822 if (factorsNv == NULL) return(NULL);
1823 freeNv = FactorsNotStored(factorsNv);
1824 factorsNv = (freeNv) ? FactorsUncomplement(factorsNv) : factorsNv;
1825 cuddRef(factorsNv->g);
1826 cuddRef(factorsNv->h);
1827
1828 /* Deal with the zero case */
1829 if (Nnv == zero) {
1830 /* is responsible for freeing factorsNv */
1831 factors = ZeroCase(dd, node, factorsNv, ghTable,
1832 cacheTable, switched);
1833 if (freeNv) FREE(factorsNv);
1834 return(factors);
1835 }
1836 }
1837
1838 /* build ge, he recursively */
1839 if (Nnv != zero) {
1840 factorsNnv = BuildConjuncts(dd, Nnv, distanceTable,
1841 cacheTable, approxDistance, maxLocalRef,
1842 ghTable, mintermTable);
1843 if (factorsNnv == NULL) {
1844 Cudd_RecursiveDeref(dd, factorsNv->g);
1845 Cudd_RecursiveDeref(dd, factorsNv->h);
1846 if (freeNv) FREE(factorsNv);
1847 return(NULL);
1848 }
1849 freeNnv = FactorsNotStored(factorsNnv);
1850 factorsNnv = (freeNnv) ? FactorsUncomplement(factorsNnv) : factorsNnv;
1851 cuddRef(factorsNnv->g);
1852 cuddRef(factorsNnv->h);
1853
1854 /* Deal with the zero case */
1855 if (Nv == zero) {
1856 /* is responsible for freeing factorsNv */
1857 factors = ZeroCase(dd, node, factorsNnv, ghTable,
1858 cacheTable, switched);
1859 if (freeNnv) FREE(factorsNnv);
1860 return(factors);
1861 }
1862 }
1863
1864 /* construct the 2 pairs */
1865 /* g1 = x*gt + x'*ge; h1 = x*ht + x'*he; */
1866 /* g2 = x*gt + x'*he; h2 = x*ht + x'*ge */
1867 if (switched) {
1868 factors = factorsNnv;
1869 factorsNnv = factorsNv;
1870 factorsNv = factors;
1871 freeTemp = freeNv;
1872 freeNv = freeNnv;
1873 freeNnv = freeTemp;
1874 }
1875
1876 /* Build the factors for this node. */
1877 topid = N->index;
1878 topv = dd->vars[topid];
1879
1880 g1 = cuddBddIteRecur(dd, topv, factorsNv->g, factorsNnv->g);
1881 if (g1 == NULL) {
1882 Cudd_RecursiveDeref(dd, factorsNv->g);
1883 Cudd_RecursiveDeref(dd, factorsNv->h);
1884 Cudd_RecursiveDeref(dd, factorsNnv->g);
1885 Cudd_RecursiveDeref(dd, factorsNnv->h);
1886 if (freeNv) FREE(factorsNv);
1887 if (freeNnv) FREE(factorsNnv);
1888 return(NULL);
1889 }
1890
1891 cuddRef(g1);
1892
1893 h1 = cuddBddIteRecur(dd, topv, factorsNv->h, factorsNnv->h);
1894 if (h1 == NULL) {
1895 Cudd_RecursiveDeref(dd, factorsNv->g);
1896 Cudd_RecursiveDeref(dd, factorsNv->h);
1897 Cudd_RecursiveDeref(dd, factorsNnv->g);
1898 Cudd_RecursiveDeref(dd, factorsNnv->h);
1899 Cudd_RecursiveDeref(dd, g1);
1900 if (freeNv) FREE(factorsNv);
1901 if (freeNnv) FREE(factorsNnv);
1902 return(NULL);
1903 }
1904
1905 cuddRef(h1);
1906
1907 g2 = cuddBddIteRecur(dd, topv, factorsNv->g, factorsNnv->h);
1908 if (g2 == NULL) {
1909 Cudd_RecursiveDeref(dd, factorsNv->h);
1910 Cudd_RecursiveDeref(dd, factorsNv->g);
1911 Cudd_RecursiveDeref(dd, factorsNnv->g);
1912 Cudd_RecursiveDeref(dd, factorsNnv->h);
1913 Cudd_RecursiveDeref(dd, g1);
1914 Cudd_RecursiveDeref(dd, h1);
1915 if (freeNv) FREE(factorsNv);
1916 if (freeNnv) FREE(factorsNnv);
1917 return(NULL);
1918 }
1919 cuddRef(g2);
1920 Cudd_RecursiveDeref(dd, factorsNv->g);
1921 Cudd_RecursiveDeref(dd, factorsNnv->h);
1922
1923 h2 = cuddBddIteRecur(dd, topv, factorsNv->h, factorsNnv->g);
1924 if (h2 == NULL) {
1925 Cudd_RecursiveDeref(dd, factorsNv->g);
1926 Cudd_RecursiveDeref(dd, factorsNv->h);
1927 Cudd_RecursiveDeref(dd, factorsNnv->g);
1928 Cudd_RecursiveDeref(dd, factorsNnv->h);
1929 Cudd_RecursiveDeref(dd, g1);
1930 Cudd_RecursiveDeref(dd, h1);
1931 Cudd_RecursiveDeref(dd, g2);
1932 if (freeNv) FREE(factorsNv);
1933 if (freeNnv) FREE(factorsNnv);
1934 return(NULL);
1935 }
1936 cuddRef(h2);
1937 Cudd_RecursiveDeref(dd, factorsNv->h);
1938 Cudd_RecursiveDeref(dd, factorsNnv->g);
1939 if (freeNv) FREE(factorsNv);
1940 if (freeNnv) FREE(factorsNnv);
1941
1942 /* check for each pair in tables and choose one */
1943 factors = CheckInTables(node, g1, h1, g2, h2, ghTable, cacheTable, &outOfMem);
1944 if (outOfMem) {
1945 dd->errorCode = CUDD_MEMORY_OUT;
1946 Cudd_RecursiveDeref(dd, g1);
1947 Cudd_RecursiveDeref(dd, h1);
1948 Cudd_RecursiveDeref(dd, g2);
1949 Cudd_RecursiveDeref(dd, h2);
1950 return(NULL);
1951 }
1952 if (factors != NULL) {
1953 if ((factors->g == g1) || (factors->g == h1)) {
1954 Cudd_RecursiveDeref(dd, g2);
1955 Cudd_RecursiveDeref(dd, h2);
1956 } else {
1957 Cudd_RecursiveDeref(dd, g1);
1958 Cudd_RecursiveDeref(dd, h1);
1959 }
1960 return(factors);
1961 }
1962
1963 /* if not in tables, pick one pair */
1964 factors = PickOnePair(node,g1, h1, g2, h2, ghTable, cacheTable);
1965 if (factors == NULL) {
1966 dd->errorCode = CUDD_MEMORY_OUT;
1967 Cudd_RecursiveDeref(dd, g1);
1968 Cudd_RecursiveDeref(dd, h1);
1969 Cudd_RecursiveDeref(dd, g2);
1970 Cudd_RecursiveDeref(dd, h2);
1971 } else {
1972 /* now free what was created and not used */
1973 if ((factors->g == g1) || (factors->g == h1)) {
1974 Cudd_RecursiveDeref(dd, g2);
1975 Cudd_RecursiveDeref(dd, h2);
1976 } else {
1977 Cudd_RecursiveDeref(dd, g1);
1978 Cudd_RecursiveDeref(dd, h1);
1979 }
1980 }
1981
1982 return(factors);
1983
1984} /* end of BuildConjuncts */
1985
1986
1987/**Function********************************************************************
1988
1989 Synopsis [Procedure to compute two conjunctive factors of f and place in *c1 and *c2.]
1990
1991 Description [Procedure to compute two conjunctive factors of f and
1992 place in *c1 and *c2. Sets up the required data - table of distances
1993 from the constant and local reference count. Also minterm table. ]
1994
1995 SideEffects []
1996
1997 SeeAlso []
1998
1999******************************************************************************/
2000static int
2001cuddConjunctsAux(
2002 DdManager * dd,
2003 DdNode * f,
2004 DdNode ** c1,
2005 DdNode ** c2)
2006{
2007 st_table *distanceTable = NULL;
2008 st_table *cacheTable = NULL;
2009 st_table *mintermTable = NULL;
2010 st_table *ghTable = NULL;
2011 st_generator *stGen;
2012 char *key, *value;
2013 Conjuncts *factors;
2014 int distance, approxDistance;
2015 double max, minterms;
2016 int freeFactors;
2017 NodeStat *nodeStat;
2018 int maxLocalRef;
2019
2020 /* initialize */
2021 *c1 = NULL;
2022 *c2 = NULL;
2023
2024 /* initialize distances table */
2025 distanceTable = st_init_table(st_ptrcmp,st_ptrhash);
2026 if (distanceTable == NULL) goto outOfMem;
2027
2028 /* make the entry for the constant */
2029 nodeStat = ALLOC(NodeStat, 1);
2030 if (nodeStat == NULL) goto outOfMem;
2031 nodeStat->distance = 0;
2032 nodeStat->localRef = 1;
2033 if (st_insert(distanceTable, (char *)one, (char *)nodeStat) == ST_OUT_OF_MEM) {
2034 goto outOfMem;
2035 }
2036
2037 /* Count node distances from constant. */
2038 nodeStat = CreateBotDist(f, distanceTable);
2039 if (nodeStat == NULL) goto outOfMem;
2040
2041 /* set the distance for the decomposition points */
2042 approxDistance = (DEPTH < nodeStat->distance) ? nodeStat->distance : DEPTH;
2043 distance = nodeStat->distance;
2044
2045 if (distance < approxDistance) {
2046 /* Too small to bother. */
2047 *c1 = f;
2048 *c2 = DD_ONE(dd);
2049 cuddRef(*c1); cuddRef(*c2);
2050 stGen = st_init_gen(distanceTable);
2051 if (stGen == NULL) goto outOfMem;
2052 while(st_gen(stGen, (char **)&key, (char **)&value)) {
2053 FREE(value);
2054 }
2055 st_free_gen(stGen); stGen = NULL;
2056 st_free_table(distanceTable);
2057 return(1);
2058 }
2059
2060 /* record the maximum local reference count */
2061 maxLocalRef = 0;
2062 stGen = st_init_gen(distanceTable);
2063 if (stGen == NULL) goto outOfMem;
2064 while(st_gen(stGen, (char **)&key, (char **)&value)) {
2065 nodeStat = (NodeStat *)value;
2066 maxLocalRef = (nodeStat->localRef > maxLocalRef) ?
2067 nodeStat->localRef : maxLocalRef;
2068 }
2069 st_free_gen(stGen); stGen = NULL;
2070
2071
2072 /* Count minterms for each node. */
2073 max = pow(2.0, (double)Cudd_SupportSize(dd,f)); /* potential overflow */
2074 mintermTable = st_init_table(st_ptrcmp,st_ptrhash);
2075 if (mintermTable == NULL) goto outOfMem;
2076 minterms = CountMinterms(f, max, mintermTable, dd->err);
2077 if (minterms == -1.0) goto outOfMem;
2078
2079 lastTimeG = Cudd_Random() & 1;
2080 cacheTable = st_init_table(st_ptrcmp, st_ptrhash);
2081 if (cacheTable == NULL) goto outOfMem;
2082 ghTable = st_init_table(st_ptrcmp, st_ptrhash);
2083 if (ghTable == NULL) goto outOfMem;
2084
2085 /* Build conjuncts. */
2086 factors = BuildConjuncts(dd, f, distanceTable, cacheTable,
2087 approxDistance, maxLocalRef, ghTable, mintermTable);
2088 if (factors == NULL) goto outOfMem;
2089
2090 /* free up tables */
2091 stGen = st_init_gen(distanceTable);
2092 if (stGen == NULL) goto outOfMem;
2093 while(st_gen(stGen, (char **)&key, (char **)&value)) {
2094 FREE(value);
2095 }
2096 st_free_gen(stGen); stGen = NULL;
2097 st_free_table(distanceTable); distanceTable = NULL;
2098 st_free_table(ghTable); ghTable = NULL;
2099
2100 stGen = st_init_gen(mintermTable);
2101 if (stGen == NULL) goto outOfMem;
2102 while(st_gen(stGen, (char **)&key, (char **)&value)) {
2103 FREE(value);
2104 }
2105 st_free_gen(stGen); stGen = NULL;
2106 st_free_table(mintermTable); mintermTable = NULL;
2107
2108 freeFactors = FactorsNotStored(factors);
2109 factors = (freeFactors) ? FactorsUncomplement(factors) : factors;
2110 if (factors != NULL) {
2111 *c1 = factors->g;
2112 *c2 = factors->h;
2113 cuddRef(*c1);
2114 cuddRef(*c2);
2115 if (freeFactors) FREE(factors);
2116
2117#if 0
2118 if ((*c1 == f) && (!Cudd_IsConstant(f))) {
2119 assert(*c2 == one);
2120 }
2121 if ((*c2 == f) && (!Cudd_IsConstant(f))) {
2122 assert(*c1 == one);
2123 }
2124
2125 if ((*c1 != one) && (!Cudd_IsConstant(f))) {
2126 assert(!Cudd_bddLeq(dd, *c2, *c1));
2127 }
2128 if ((*c2 != one) && (!Cudd_IsConstant(f))) {
2129 assert(!Cudd_bddLeq(dd, *c1, *c2));
2130 }
2131#endif
2132 }
2133
2134 stGen = st_init_gen(cacheTable);
2135 if (stGen == NULL) goto outOfMem;
2136 while(st_gen(stGen, (char **)&key, (char **)&value)) {
2137 ConjunctsFree(dd, (Conjuncts *)value);
2138 }
2139 st_free_gen(stGen); stGen = NULL;
2140
2141 st_free_table(cacheTable); cacheTable = NULL;
2142
2143 return(1);
2144
2145outOfMem:
2146 if (distanceTable != NULL) {
2147 stGen = st_init_gen(distanceTable);
2148 if (stGen == NULL) goto outOfMem;
2149 while(st_gen(stGen, (char **)&key, (char **)&value)) {
2150 FREE(value);
2151 }
2152 st_free_gen(stGen); stGen = NULL;
2153 st_free_table(distanceTable); distanceTable = NULL;
2154 }
2155 if (mintermTable != NULL) {
2156 stGen = st_init_gen(mintermTable);
2157 if (stGen == NULL) goto outOfMem;
2158 while(st_gen(stGen, (char **)&key, (char **)&value)) {
2159 FREE(value);
2160 }
2161 st_free_gen(stGen); stGen = NULL;
2162 st_free_table(mintermTable); mintermTable = NULL;
2163 }
2164 if (ghTable != NULL) st_free_table(ghTable);
2165 if (cacheTable != NULL) {
2166 stGen = st_init_gen(cacheTable);
2167 if (stGen == NULL) goto outOfMem;
2168 while(st_gen(stGen, (char **)&key, (char **)&value)) {
2169 ConjunctsFree(dd, (Conjuncts *)value);
2170 }
2171 st_free_gen(stGen); stGen = NULL;
2172 st_free_table(cacheTable); cacheTable = NULL;
2173 }
2174 dd->errorCode = CUDD_MEMORY_OUT;
2175 return(0);
2176
2177} /* end of cuddConjunctsAux */
Note: See TracBrowser for help on using the repository browser.