Menu
▾
▴
[Javabdd-checkins] JavaBDD/buddy/src trace.c,NONE,1.1 trace.h,NONE,1.1 bdd.h,1.1.1.1,1.2 bddio.c,1.1.1.1,1.2 bddop.c,1.1.1.1,1.2 fdd.c,1.1.1.1,1.2 kernel.c,1.1.1.1,1.2 pairs.c,1.1.1.1,1.2 reorder.c,1.1.1.1,1.2
Update of /cvsroot/javabdd/JavaBDD/buddy/src In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24254 Modified Files: bdd.h bddio.c bddop.c fdd.c kernel.c pairs.c reorder.c Added Files: trace.c trace.h Log Message: Index: reorder.c =================================================================== RCS file: /cvsroot/javabdd/JavaBDD/buddy/src/reorder.c,v retrieving revision 1.1.1.1 retrieving revision 1.2 diff -C2 -d -r1.1.1.1 -r1.2 *** reorder.c 29 Sep 2004 09:50:25 -0000 1.1.1.1 --- reorder.c 29 Sep 2004 10:00:50 -0000 1.2 *************** *** 1524,1538 **** int l1, l2; /* Do not swap when variable-blocks are used */ if (vartree != NULL) ! return bdd_error(BDD_VARBLK); /* Don't bother swapping x with x */ if (v1 == v2) ! return 0; /* Make sure the variable exists */ if (v1 < 0 || v1 >= bddvarnum || v2 < 0 || v2 >= bddvarnum) ! return bdd_error(BDD_VAR); l1 = bddvar2level[v1]; --- 1524,1542 ---- int l1, l2; + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,v1); + ADD_ARG1(T_INT,v2); + /* Do not swap when variable-blocks are used */ if (vartree != NULL) ! RETURN(bdd_error(BDD_VARBLK)); /* Don't bother swapping x with x */ if (v1 == v2) ! RETURN(0); /* Make sure the variable exists */ if (v1 < 0 || v1 >= bddvarnum || v2 < 0 || v2 >= bddvarnum) ! RETURN(bdd_error(BDD_VAR)); l1 = bddvar2level[v1]; *************** *** 1561,1565 **** reorder_done(); ! return 0; } --- 1565,1569 ---- reorder_done(); ! RETURN(0); } *************** *** 1598,1602 **** --- 1602,1608 ---- void bdd_disable_reorder(void) { + BUDDY_PROLOGUE; reorderdisabled = 1; + RETURN(); } *************** *** 1612,1616 **** --- 1618,1624 ---- void bdd_enable_reorder(void) { + BUDDY_PROLOGUE; reorderdisabled = 0; + RETURN(); } *************** *** 1804,1807 **** --- 1812,1818 ---- int savemethod = bddreordermethod; int savetimes = bddreordertimes; + + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,method); bddreordermethod = method; *************** *** 1809,1815 **** if ((top=bddtree_new(-1)) == NULL) ! return; if (reorder_init() < 0) ! return; usednum_before = bddnodesize - bddfreenum; --- 1820,1826 ---- if ((top=bddtree_new(-1)) == NULL) ! RETURN(); if (reorder_init() < 0) ! RETURN(); usednum_before = bddnodesize - bddfreenum; *************** *** 1830,1833 **** --- 1841,1845 ---- bddreordermethod = savemethod; bddreordertimes = savetimes; + RETURN(); } *************** *** 1847,1854 **** int bdd_reorder_gain(void) { if (usednum_before == 0) ! return 0; ! return (100*(usednum_before - usednum_after)) / usednum_before; } --- 1859,1867 ---- int bdd_reorder_gain(void) { + BUDDY_PROLOGUE; if (usednum_before == 0) ! RETURN(0); ! RETURN((100*(usednum_before - usednum_after)) / usednum_before); } *************** *** 1948,1954 **** { int tmp = bddreordermethod; bddreordermethod = method; bddreordertimes = -1; ! return tmp; } --- 1961,1969 ---- { int tmp = bddreordermethod; + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,method); bddreordermethod = method; bddreordertimes = -1; ! RETURN(tmp); } *************** *** 1957,1963 **** { int tmp = bddreordermethod; bddreordermethod = method; bddreordertimes = num; ! return tmp; } --- 1972,1981 ---- { int tmp = bddreordermethod; + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,method); + ADD_ARG1(T_INT,num); bddreordermethod = method; bddreordertimes = num; ! RETURN(tmp); } *************** *** 1974,1981 **** int bdd_var2level(int var) { if (var < 0 || var >= bddvarnum) ! return bdd_error(BDD_VAR); ! return bddvar2level[var]; } --- 1992,2001 ---- int bdd_var2level(int var) { + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,var); if (var < 0 || var >= bddvarnum) ! RETURN(bdd_error(BDD_VAR)); ! RETURN(bddvar2level[var]); } *************** *** 1992,1999 **** int bdd_level2var(int level) { if (level < 0 || level >= bddvarnum) ! return bdd_error(BDD_VAR); ! return bddlevel2var[level]; } --- 2012,2021 ---- int bdd_level2var(int level) { + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,level); if (level < 0 || level >= bddvarnum) ! RETURN(bdd_error(BDD_VAR)); ! RETURN(bddlevel2var[level]); } *************** *** 2010,2014 **** int bdd_getreorder_times(void) { ! return bddreordertimes; } --- 2032,2037 ---- int bdd_getreorder_times(void) { ! BUDDY_PROLOGUE; ! RETURN(bddreordertimes); } *************** *** 2025,2029 **** int bdd_getreorder_method(void) { ! return bddreordermethod; } --- 2048,2053 ---- int bdd_getreorder_method(void) { ! BUDDY_PROLOGUE; ! RETURN(bddreordermethod); } *************** *** 2045,2050 **** { int tmp = verbose; verbose = v; ! return tmp; } --- 2069,2076 ---- { int tmp = verbose; + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,v); verbose = v; ! RETURN(tmp); } *************** *** 2078,2084 **** --- 2104,2115 ---- { bddsizehandler old = reorder_nodenum; + BUDDY_IGNOREFN_PROLOGUE; if (handler == NULL) + { + BUDDY_IGNOREFN_EPILOGUE; return reorder_nodenum; + } reorder_nodenum = handler; + BUDDY_IGNOREFN_EPILOGUE; return old; } *************** *** 2096,2102 **** --- 2127,2135 ---- void bdd_clrvarblocks(void) { + BUDDY_PROLOGUE; bddtree_del(vartree); vartree = NULL; blockid = 0; + RETURN(); } *************** *** 2142,2150 **** int n, *v, size; int first, last; if ((n=bdd_scanset(b, &v, &size)) < 0) ! return n; if (size < 1) ! return bdd_error(BDD_VARBLK); first = last = v[0]; --- 2175,2187 ---- int n, *v, size; int first, last; + + BUDDY_PROLOGUE; + ADD_ARG1(T_BDD,b); + ADD_ARG1(T_INT,fixed); if ((n=bdd_scanset(b, &v, &size)) < 0) ! RETURN(n); if (size < 1) ! RETURN(bdd_error(BDD_VARBLK)); first = last = v[0]; *************** *** 2159,2166 **** if ((t=bddtree_addrange(vartree, first,last, fixed,blockid)) == NULL) ! return bdd_error(BDD_VARBLK); vartree = t; ! return blockid++; } --- 2196,2203 ---- if ((t=bddtree_addrange(vartree, first,last, fixed,blockid)) == NULL) ! RETURN(bdd_error(BDD_VARBLK)); vartree = t; ! RETURN(blockid++); } *************** *** 2169,2181 **** { BddTree *t; if (first < 0 || first >= bddvarnum || last < 0 || last >= bddvarnum) ! return bdd_error(BDD_VAR); if ((t=bddtree_addrange(vartree, first,last, fixed,blockid)) == NULL) ! return bdd_error(BDD_VARBLK); vartree = t; ! return blockid++; } --- 2206,2222 ---- { BddTree *t; + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,first); + ADD_ARG1(T_INT,last); + ADD_ARG1(T_INT,fixed); if (first < 0 || first >= bddvarnum || last < 0 || last >= bddvarnum) ! RETURN(bdd_error(BDD_VAR)); if ((t=bddtree_addrange(vartree, first,last, fixed,blockid)) == NULL) ! RETURN(bdd_error(BDD_VARBLK)); vartree = t; ! RETURN(blockid++); } *************** *** 2197,2202 **** --- 2238,2246 ---- int n; + BUDDY_PROLOGUE; + for (n=0 ; n<bddvarnum ; n++) bdd_intaddvarblock(n,n,1); + RETURN(); } *************** *** 2230,2234 **** --- 2274,2280 ---- void bdd_printorder(void) { + BUDDY_PROLOGUE; bdd_fprintorder(stdout); + RETURN(); } *************** *** 2252,2260 **** int level; /* Do not set order when variable-blocks are used */ if (vartree != NULL) { bdd_error(BDD_VARBLK); ! return; } --- 2298,2309 ---- int level; + BUDDY_PROLOGUE; + ADD_ARG2(T_INT_PTR,neworder,bddvarnum); + /* Do not set order when variable-blocks are used */ if (vartree != NULL) { bdd_error(BDD_VARBLK); ! RETURN(); } *************** *** 2270,2273 **** --- 2319,2323 ---- reorder_done(); + RETURN(); } Index: bddio.c =================================================================== RCS file: /cvsroot/javabdd/JavaBDD/buddy/src/bddio.c,v retrieving revision 1.1.1.1 retrieving revision 1.2 diff -C2 -d -r1.1.1.1 -r1.2 *** bddio.c 29 Sep 2004 09:50:25 -0000 1.1.1.1 --- bddio.c 29 Sep 2004 10:00:49 -0000 1.2 *************** *** 119,123 **** --- 119,125 ---- void bdd_printall(void) { + BUDDY_PROLOGUE; bdd_fprintall(stdout); + RETURN(); } *************** *** 163,167 **** --- 165,172 ---- void bdd_printtable(BDD r) { + BUDDY_PROLOGUE; + ADD_ARG1(T_BDD,r); bdd_fprinttable(stdout, r); + RETURN(); } *************** *** 226,230 **** --- 231,238 ---- void bdd_printset(BDD r) { + BUDDY_PROLOGUE; + ADD_ARG1(T_BDD,r); bdd_fprintset(stdout, r); + RETURN(); } *************** *** 312,316 **** --- 320,327 ---- void bdd_printdot(BDD r) { + BUDDY_PROLOGUE; + ADD_ARG1(T_BDD,r); bdd_fprintdot(stdout, r); + RETURN(); } *************** *** 384,393 **** int ok; if ((ofile=fopen(fname,"w")) == NULL) ! return bdd_error(BDD_FILE); ok = bdd_save(ofile, r); fclose(ofile); ! return ok; } --- 395,408 ---- int ok; + BUDDY_PROLOGUE; + ADD_ARG1(T_CHAR_PTR,fname); + ADD_ARG1(T_BDD,r); + if ((ofile=fopen(fname,"w")) == NULL) ! RETURN(bdd_error(BDD_FILE)); ok = bdd_save(ofile, r); fclose(ofile); ! RETURN(ok); } *************** *** 478,487 **** int ok; if ((ifile=fopen(fname,"r")) == NULL) ! return bdd_error(BDD_FILE); ok = bdd_load(ifile, root); fclose(ifile); ! return ok; } --- 493,510 ---- int ok; + BUDDY_PROLOGUE; + ADD_ARG1(T_CHAR_PTR,fname); + if ((ifile=fopen(fname,"r")) == NULL) ! { ! ! ADD_ARG1(T_BDD_LOAD,*root); ! RETURN(bdd_error(BDD_FILE)); ! } ok = bdd_load(ifile, root); + ADD_ARG1(T_BDD_LOAD,*root); fclose(ifile); ! RETURN(ok); } *************** *** 533,541 **** else *root = tmproot; - return 0; } - static int bdd_loaddata(FILE *ifile) { --- 556,562 ---- --- NEW FILE: trace.c --- #ifdef GENERATE_TRACE #include <unistd.h> #include <stdio.h> #include <stdlib.h> #include <assert.h> #include <string.h> #include "bdd.h" #ifndef EXIT_FAILURE #define EXIT_FAILURE -1 #endif /* Simple trace file generation */ FILE * tracefp; const char * trace_fname; #define NR_TABLE (1<<16) #define HASH_MASK ((NR_TABLE)-1) struct bdd_decl { struct bdd_decl * next; union { BDD bval; bddPair * pval; }; int is_pair, is_collected; const char * identifier; }; struct bdd_decl * decltbl[NR_TABLE]; struct bdd_arg { struct bdd_arg * next; enum arg_type type; union { const char * ident; /* T_BDD, T_BDD_PAIR */ struct /* T_BDD_PTR */ { BDD * barr; int blen; }; struct /* T_INT_PTR */ { int * iarr; int len; }; char * str; /* T_CHAR_PTR */ int i; /* T_INT */ }; }; struct bdd_function { struct bdd_function * next, * prev; const char * fn_ident; struct bdd_arg * args; /* NULL if void */ const char * retval; }; struct bdd_function * currfn; struct bdd_function * bddfns; const char * last_id; static unsigned long hash_bdd(BDD b) { return (unsigned long)b & HASH_MASK; } static unsigned long hash_bddpair(bddPair * p) { unsigned long tmp = (unsigned long)p; return tmp & HASH_MASK; } static __inline__ int id_done(const char * id) { const char * pos = id + 4; /* skip _bdd header */ while(*pos == 'z') pos++; if(*pos == '\0') return 1; return 0; } static const char * genid(void) { char * retval; int i,j; if(!last_id) { retval = "_bdda"; } else if(id_done(last_id)) { retval = xmalloc(strlen(last_id) + 2); memcpy(retval,"_bdd",4); memset(retval+4,'a',strlen(last_id)-4 + 1); retval[strlen(last_id)+1] = '\0'; } else { for(i = 4; last_id[i] == 'z' ; i++) ; retval = strdup(last_id); for(j = 4; j < i; j++) retval[j] = 'a'; retval[i]++; } last_id = retval; return retval; } static struct bdd_decl * lookup_bdd(enum arg_type type, void * arg) { struct bdd_decl * d; if(type == T_BDD) { BDD b = (BDD) arg; d = decltbl[hash_bdd(b)]; while(d) { if(!(d->is_pair) && d->bval == b && !d->is_collected) return d; d = d->next; } } else if(type == T_BDD_PAIR) { bddPair * p = (bddPair *) arg; d = decltbl[hash_bddpair(p)]; while(d) { if( d->is_pair && d->pval == p & !d->is_collected) { return d; } d = d->next; } } else assert(0); return NULL; } static const char * lookup_bdd_ident(enum arg_type type, void * arg) { struct bdd_decl * d; if(type == T_BDD) { BDD b = (BDD) arg; if(b == bddtrue) return "bddtrue"; if(b == bddfalse) return "bddfalse"; } d = lookup_bdd(type,arg); if(!d) return NULL; return d->identifier; } void trace_init(const char * filename) { tracefp = fopen(filename,"w"); if(!tracefp) { fprintf(stderr,"Unable to open file %s for tracing\n",filename); exit(EXIT_FAILURE); } atexit(output_trace); memset(decltbl, 0, sizeof(decltbl)); currfn = NULL; bddfns = NULL; } void trace_begin_function(const char * fn) { assert(!currfn); currfn = xmalloc(sizeof(struct bdd_function)); currfn->fn_ident = fn; currfn->retval = NULL; currfn->args = NULL; currfn->next = currfn->prev = currfn; } void trace_end_function(void) { if(bddfns == NULL) bddfns = currfn; else { bddfns->prev->next = currfn; currfn->next = bddfns; currfn->prev = bddfns->prev; bddfns->prev = currfn; } currfn = NULL; } void trace_add_bdd(enum arg_type type, void * retval) { if(!lookup_bdd_ident(type,retval)) { struct bdd_decl * d = xmalloc(sizeof(struct bdd_decl)); d->identifier = genid(); d->is_pair = type == T_BDD_PAIR; d->is_collected = 0; if(type == T_BDD) { BDD b = (BDD) retval; d->bval = b; d->next = decltbl[hash_bdd(b)]; decltbl[hash_bdd(b)] = d; } else { bddPair * p = (bddPair *) retval; if(!p) { printf("ERROR at %s\n",__func__); return; } d->pval = p; d->next = decltbl[hash_bddpair(p)]; decltbl[hash_bddpair(p)] = d; } } } void trace_del_bdd(enum arg_type type, void * arg) { struct bdd_decl * d = lookup_bdd(type,arg); if(d) { if(type == T_BDD_PAIR) printf("removing pair\n"); d->is_collected = 1; } } void * trace_end_function_bdd(enum arg_type type, void * retval) { const char * id; trace_add_bdd(type,retval); id = lookup_bdd_ident(type,retval); assert(id); currfn->retval = id; trace_end_function(); return retval; } void trace_add_arg(enum arg_type type, void * arg1, void * arg2) { struct bdd_arg *a = xmalloc(sizeof(struct bdd_arg)); a->next = NULL; a->type = type; switch(type) { case T_INT: a->i = (int) arg1; break; case T_INT_PTR: a->len = (int) arg2; a->iarr = xmalloc(a->len * sizeof(int)); memcpy(a->iarr,arg1,a->len * sizeof(int)); break; case T_CHAR_PTR: a->str = strdup((char *)arg1); break; case T_BDD: case T_BDD_PAIR: a->ident = lookup_bdd_ident(type,arg1); assert(a->ident); break; case T_BDD_LOAD: { BDD b = (BDD) arg1; trace_add_bdd(T_BDD,(void *)b); a->ident = lookup_bdd_ident(T_BDD,(void *)b); assert(a->ident); break; } case T_BDD_PTR: { int i; a->blen = (int) arg2; a->barr = malloc(sizeof(BDD) * a->blen); memcpy(a->barr,arg1,sizeof(BDD) * a->blen); /* broken code manufactures bdds and then * passes them as aray elements. bleh */ for(i = 0; i < a->blen; i++) { trace_add_bdd(T_BDD,(void *)a->barr[i]); } break; } default: assert(0); } if(currfn->args == NULL) currfn->args = a; else { struct bdd_arg * c = currfn->args; while(c->next) c = c->next; c->next = a; } } static void print_args(struct bdd_arg * args) { struct bdd_arg * a = args; while(a) { switch(a->type) { case T_INT: fprintf(tracefp,"%d",a->i); break; case T_INT_PTR: { int i; fprintf(tracefp,"(int []) { "); for(i = 0; i < a->len; i++) fprintf(tracefp,"%d,", a->iarr[i]); fprintf(tracefp,"}"); break; } case T_CHAR_PTR: fprintf(tracefp,"\"%s\"",a->str); break; case T_BDD: case T_BDD_PAIR: fprintf(tracefp,"%s",a->ident); break; case T_BDD_LOAD: fprintf(tracefp,"&%s",a->ident); break; case T_BDD_PTR: { int i; fprintf(tracefp, "(BDD []) {"); for(i = 0; i < a->blen; i++) { fprintf(tracefp,"%s,", lookup_bdd_ident(T_BDD,(void *)a->barr[i])); } fprintf(tracefp,"}"); break; } default: assert(0); } if(a->next) fprintf(tracefp,","); a = a->next; } } void emit_header(void) { fprintf(tracefp,"#include \"bdd.h\"\n"); fprintf(tracefp,"int main(void)\n{\n"); } void emit_trailer(void) { fprintf(tracefp,"return 0; }\n"); } void output_trace(void) { if(trace_outputted) return; trace_outputted = 1; int i, first = 0; struct bdd_function * f; emit_header(); for(i = 0; i < NR_TABLE; i++) { struct bdd_decl * d = decltbl[i]; while(d) { if(d->is_pair) fprintf(tracefp,"\tbddPair *"); else fprintf(tracefp,"\tBDD "); fprintf(tracefp,"%s;\n",d->identifier); d = d->next; } } f = bddfns; while(f != bddfns || !first) { if(f->retval && strcmp(f->retval,"bddtrue") && strcmp(f->retval,"bddfalse")) fprintf(tracefp,"\n\t%s = ", f->retval); else fprintf(tracefp,"\n\t"); fprintf(tracefp, f->fn_ident); fprintf(tracefp,"("); print_args(f->args); fprintf(tracefp,");"); f = f->next; first = 1; } emit_trailer(); } #endif // GENERATE_TRACE Index: bddop.c =================================================================== RCS file: /cvsroot/javabdd/JavaBDD/buddy/src/bddop.c,v retrieving revision 1.1.1.1 retrieving revision 1.2 diff -C2 -d -r1.1.1.1 -r1.2 *** bddop.c 29 Sep 2004 09:50:25 -0000 1.1.1.1 --- bddop.c 29 Sep 2004 10:00:50 -0000 1.2 *************** *** 122,129 **** --- 122,131 ---- static BDD not_rec(BDD); static BDD apply_rec(BDD, BDD); + static BDD apply_rec0(BDD, BDD); static BDD ite_rec(BDD, BDD, BDD); static int simplify_rec(BDD, BDD); static int quant_rec(int); static int appquant_rec(int, int); + static int appquant_rec0(int, int); static int restrict_rec(int); [...1532 lines suppressed...] { CHECKa(r, 0.0); miscid = CACHEID_PATHCOU; ! return bdd_pathcount_rec(r); } --- 3119,3129 ---- double bdd_pathcount(BDD r) { + BUDDY_PROLOGUE; + ADD_ARG1(T_BDD,r); CHECKa(r, 0.0); miscid = CACHEID_PATHCOU; ! RETURN(bdd_pathcount_rec(r)); } Index: fdd.c =================================================================== RCS file: /cvsroot/javabdd/JavaBDD/buddy/src/fdd.c,v retrieving revision 1.1.1.1 retrieving revision 1.2 diff -C2 -d -r1.1.1.1 -r1.2 *** fdd.c 29 Sep 2004 09:50:25 -0000 1.1.1.1 --- fdd.c 29 Sep 2004 10:00:50 -0000 1.2 *************** *** 128,133 **** int n, bn, more; if (!bddrunning) ! return bdd_error(BDD_RUNNING); /* Build domain table */ --- 128,137 ---- int n, bn, more; + BUDDY_PROLOGUE; + ADD_ARG2(T_INT_PTR,dom,num); + ADD_ARG1(T_INT,num); + if (!bddrunning) ! RETURN(bdd_error(BDD_RUNNING)); /* Build domain table */ *************** *** 136,140 **** fdvaralloc = num; if ((domain=(Domain*)malloc(sizeof(Domain)*num)) == NULL) ! return bdd_error(BDD_MEMORY); } else /* Allocated before */ --- 140,144 ---- fdvaralloc = num; if ((domain=(Domain*)malloc(sizeof(Domain)*num)) == NULL) ! RETURN(bdd_error(BDD_MEMORY)); } else /* Allocated before */ *************** *** 146,150 **** domain = (Domain*)realloc(domain, sizeof(Domain)*fdvaralloc); if (domain == NULL) ! return bdd_error(BDD_MEMORY); } } --- 150,154 ---- domain = (Domain*)realloc(domain, sizeof(Domain)*fdvaralloc); if (domain == NULL) ! RETURN(bdd_error(BDD_MEMORY)); } } *************** *** 184,188 **** firstbddvar += extravars; ! return offset; } --- 188,192 ---- firstbddvar += extravars; ! RETURN(offset); } *************** *** 209,218 **** Domain *d; int n; if (!bddrunning) ! return bdd_error(BDD_RUNNING); if (v1 < 0 || v1 >= fdvarnum || v2 < 0 || v2 >= fdvarnum) ! return bdd_error(BDD_VAR); if (fdvarnum + 1 > fdvaralloc) --- 213,226 ---- Domain *d; int n; + + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,v1); + ADD_ARG1(T_INT,v2); if (!bddrunning) ! RETURN(bdd_error(BDD_RUNNING)); if (v1 < 0 || v1 >= fdvarnum || v2 < 0 || v2 >= fdvarnum) ! RETURN(bdd_error(BDD_VAR)); if (fdvarnum + 1 > fdvaralloc) *************** *** 222,226 **** domain = (Domain*)realloc(domain, sizeof(Domain)*fdvaralloc); if (domain == NULL) ! return bdd_error(BDD_MEMORY); } --- 230,234 ---- domain = (Domain*)realloc(domain, sizeof(Domain)*fdvaralloc); if (domain == NULL) ! RETURN(bdd_error(BDD_MEMORY)); } *************** *** 238,242 **** bdd_addref(d->var); ! return fdvarnum++; } --- 246,250 ---- bdd_addref(d->var); ! RETURN(fdvarnum++); } *************** *** 252,257 **** --- 260,267 ---- void fdd_clearall(void) { + BUDDY_PROLOGUE; bdd_fdd_done(); bdd_fdd_init(); + RETURN(); } *************** *** 274,281 **** int fdd_domainnum(void) { if (!bddrunning) ! return bdd_error(BDD_RUNNING); ! return fdvarnum; } --- 284,292 ---- int fdd_domainnum(void) { + BUDDY_PROLOGUE; if (!bddrunning) ! RETURN(bdd_error(BDD_RUNNING)); ! RETURN(fdvarnum); } *************** *** 293,302 **** int fdd_domainsize(int v) { if (!bddrunning) ! return bdd_error(BDD_RUNNING); if (v < 0 || v >= fdvarnum) ! return bdd_error(BDD_VAR); ! return domain[v].realsize; } --- 304,315 ---- int fdd_domainsize(int v) { + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,v); if (!bddrunning) ! RETURN(bdd_error(BDD_RUNNING)); if (v < 0 || v >= fdvarnum) ! RETURN(bdd_error(BDD_VAR)); ! RETURN(domain[v].realsize); } *************** *** 314,323 **** int fdd_varnum(int v) { if (!bddrunning) ! return bdd_error(BDD_RUNNING); if (v >= fdvarnum || v < 0) ! return bdd_error(BDD_VAR); ! return domain[v].binsize; } --- 327,339 ---- int fdd_varnum(int v) { + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,v); + if (!bddrunning) ! RETURN(bdd_error(BDD_RUNNING)); if (v >= fdvarnum || v < 0) ! RETURN(bdd_error(BDD_VAR)); ! RETURN(domain[v].binsize); } *************** *** 339,346 **** int *fdd_vars(int v) { if (!bddrunning) { bdd_error(BDD_RUNNING); ! return NULL; } --- 355,365 ---- int *fdd_vars(int v) { + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,v); + if (!bddrunning) { bdd_error(BDD_RUNNING); ! RETURN(NULL); } *************** *** 348,355 **** { bdd_error(BDD_VAR); ! return NULL; } ! return domain[v].ivar; } --- 367,374 ---- { bdd_error(BDD_VAR); ! RETURN(NULL); } ! RETURN(domain[v].ivar); } *************** *** 379,387 **** int n; int v=1, tmp; if (!bddrunning) { bdd_error(BDD_RUNNING); ! return bddfalse; } --- 398,410 ---- int n; int v=1, tmp; + + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,var); + ADD_ARG1(T_INT,val); if (!bddrunning) { bdd_error(BDD_RUNNING); ! RETURN_BDD(bddfalse); } *************** *** 389,393 **** { bdd_error(BDD_VAR); ! return bddfalse; } --- 412,416 ---- { bdd_error(BDD_VAR); ! RETURN_BDD(bddfalse); } *************** *** 395,399 **** { bdd_error(BDD_RANGE); ! return bddfalse; } --- 418,422 ---- { bdd_error(BDD_RANGE); ! RETURN_BDD(bddfalse); } *************** *** 412,416 **** } ! return v; } --- 435,439 ---- } ! RETURN_BDD(v); } *************** *** 432,440 **** int res; CHECK(r); if (r == bddfalse) ! return -1; if (var < 0 || var >= fdvarnum) ! return bdd_error(BDD_VAR); allvar = fdd_scanallvar(r); --- 455,467 ---- int res; + BUDDY_PROLOGUE; + ADD_ARG1(T_BDD,r); + ADD_ARG1(T_INT,var); + CHECK(r); if (r == bddfalse) ! RETURN(-1); if (var < 0 || var >= fdvarnum) ! RETURN(bdd_error(BDD_VAR)); allvar = fdd_scanallvar(r); *************** *** 442,446 **** free(allvar); ! return res; } --- 469,473 ---- free(allvar); ! RETURN(res); } *************** *** 466,473 **** int *res; BDD p = r; CHECKa(r,NULL); if (r == bddfalse) ! return NULL; store = NEW(char,bddvarnum); --- 493,503 ---- int *res; BDD p = r; + + BUDDY_PROLOGUE; + ADD_ARG1(T_BDD,r); CHECKa(r,NULL); if (r == bddfalse) ! RETURN(NULL); store = NEW(char,bddvarnum); *************** *** 507,511 **** free(store); ! return res; } --- 537,541 ---- free(store); ! RETURN(res); } *************** *** 522,529 **** BDD fdd_ithset(int var) { if (!bddrunning) { bdd_error(BDD_RUNNING); ! return bddfalse; } --- 552,562 ---- BDD fdd_ithset(int var) { + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,var); + if (!bddrunning) { bdd_error(BDD_RUNNING); ! RETURN_BDD(bddfalse); } *************** *** 531,538 **** { bdd_error(BDD_VAR); ! return bddfalse; } ! return domain[var].var; } --- 564,571 ---- { bdd_error(BDD_VAR); ! RETURN_BDD(bddfalse); } ! RETURN_BDD(domain[var].var); } *************** *** 554,562 **** Domain *dom; BDD d; if (!bddrunning) { bdd_error(BDD_RUNNING); ! return bddfalse; } --- 587,598 ---- Domain *dom; BDD d; + + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,var); if (!bddrunning) { bdd_error(BDD_RUNNING); ! RETURN_BDD(bddfalse); } *************** *** 564,568 **** { bdd_error(BDD_VAR); ! return bddfalse; } --- 600,604 ---- { bdd_error(BDD_VAR); ! RETURN_BDD(bddfalse); } *************** *** 589,593 **** } ! return d; } --- 625,629 ---- } ! RETURN_BDD(d); } *************** *** 608,616 **** BDD e = bddtrue, tmp1, tmp2; int n; if (!bddrunning) { bdd_error(BDD_RUNNING); ! return bddfalse; } --- 644,656 ---- BDD e = bddtrue, tmp1, tmp2; int n; + + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,left); + ADD_ARG1(T_INT,right); if (!bddrunning) { bdd_error(BDD_RUNNING); ! RETURN_BDD(bddfalse); } *************** *** 618,627 **** { bdd_error(BDD_VAR); ! return bddfalse; } if (domain[left].realsize != domain[right].realsize) { bdd_error(BDD_RANGE); ! return bddfalse; } --- 658,667 ---- { bdd_error(BDD_VAR); ! RETURN_BDD(bddfalse); } if (domain[left].realsize != domain[right].realsize) { bdd_error(BDD_RANGE); ! RETURN_BDD(bddfalse); } *************** *** 639,643 **** bdd_delref(e); ! return e; } --- 679,683 ---- bdd_delref(e); ! RETURN_BDD(e); } *************** *** 893,900 **** int n; if (!bddrunning) { bdd_error(BDD_RUNNING); ! return bddfalse; } --- 933,944 ---- int n; + BUDDY_PROLOGUE; + ADD_ARG2(T_INT_PTR,varset,varnum); + ADD_ARG1(T_INT,varnum); + if (!bddrunning) { bdd_error(BDD_RUNNING); ! RETURN_BDD(bddfalse); } *************** *** 903,907 **** { bdd_error(BDD_VAR); ! return bddfalse; } --- 947,951 ---- { bdd_error(BDD_VAR); ! RETURN_BDD(bddfalse); } *************** *** 914,918 **** } ! return res; } --- 958,962 ---- } ! RETURN_BDD(res); } *************** *** 933,942 **** bdd res = bddtrue, tmp; int n, err; if (!bddrunning) ! return bdd_error(BDD_RUNNING); if (first > last || first < 0 || last >= fdvarnum) ! return bdd_error(BDD_VARBLK); for (n=first ; n<=last ; n++) --- 977,991 ---- bdd res = bddtrue, tmp; int n, err; + + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,first); + ADD_ARG1(T_INT,last); + ADD_ARG1(T_INT,fixed); if (!bddrunning) ! RETURN(bdd_error(BDD_RUNNING)); if (first > last || first < 0 || last >= fdvarnum) ! RETURN(bdd_error(BDD_VARBLK)); for (n=first ; n<=last ; n++) *************** *** 951,955 **** bdd_delref(res); ! return err; } --- 1000,1004 ---- bdd_delref(res); ! RETURN(err); } *************** *** 971,988 **** int n,e; if (!bddrunning) ! return bdd_error(BDD_RUNNING); if (p1<0 || p1>=fdvarnum || p2<0 || p2>=fdvarnum) ! return bdd_error(BDD_VAR); if (domain[p1].binsize != domain[p2].binsize) ! return bdd_error(BDD_VARNUM); for (n=0 ; n<domain[p1].binsize ; n++) if ((e=bdd_setpair(pair, domain[p1].ivar[n], domain[p2].ivar[n])) < 0) ! return e; ! return 0; } --- 1020,1042 ---- int n,e; + BUDDY_PROLOGUE; + ADD_ARG1(T_BDD_PAIR,pair); + ADD_ARG1(T_INT,p1); + ADD_ARG1(T_INT,p2); + if (!bddrunning) ! RETURN(bdd_error(BDD_RUNNING)); if (p1<0 || p1>=fdvarnum || p2<0 || p2>=fdvarnum) ! RETURN(bdd_error(BDD_VAR)); if (domain[p1].binsize != domain[p2].binsize) ! RETURN(bdd_error(BDD_VARNUM)); for (n=0 ; n<domain[p1].binsize ; n++) if ((e=bdd_setpair(pair, domain[p1].ivar[n], domain[p2].ivar[n])) < 0) ! RETURN(e); ! RETURN(0); } *************** *** 1005,1020 **** int n,e; if (!bddrunning) ! return bdd_error(BDD_RUNNING); for (n=0 ; n<size ; n++) if (p1[n]<0 || p1[n]>=fdvarnum || p2[n]<0 || p2[n]>=fdvarnum) ! return bdd_error(BDD_VAR); for (n=0 ; n<size ; n++) if ((e=fdd_setpair(pair, p1[n], p2[n])) < 0) ! return e; ! return 0; } --- 1059,1080 ---- int n,e; + BUDDY_PROLOGUE; + ADD_ARG1(T_BDD_PAIR,pair); + ADD_ARG2(T_INT_PTR,p1,size); + ADD_ARG2(T_INT_PTR,p2,size); + ADD_ARG1(T_INT,size); + if (!bddrunning) ! RETURN(bdd_error(BDD_RUNNING)); for (n=0 ; n<size ; n++) if (p1[n]<0 || p1[n]>=fdvarnum || p2[n]<0 || p2[n]>=fdvarnum) ! RETURN(bdd_error(BDD_VAR)); for (n=0 ; n<size ; n++) if ((e=fdd_setpair(pair, p1[n], p2[n])) < 0) ! RETURN(e); ! RETURN(0); } Index: pairs.c =================================================================== RCS file: /cvsroot/javabdd/JavaBDD/buddy/src/pairs.c,v retrieving revision 1.1.1.1 retrieving revision 1.2 diff -C2 -d -r1.1.1.1 -r1.2 *** pairs.c 29 Sep 2004 09:50:25 -0000 1.1.1.1 --- pairs.c 29 Sep 2004 10:00:50 -0000 1.2 *************** *** 148,156 **** int n; bddPair *p; if ((p=(bddPair*)malloc(sizeof(bddPair))) == NULL) { bdd_error(BDD_MEMORY); ! return NULL; } --- 148,158 ---- int n; bddPair *p; + + BUDDY_PROLOGUE; if ((p=(bddPair*)malloc(sizeof(bddPair))) == NULL) { bdd_error(BDD_MEMORY); ! RETURN_BDD_PAIR(NULL); } *************** *** 159,163 **** free(p); bdd_error(BDD_MEMORY); ! return NULL; } --- 161,165 ---- free(p); bdd_error(BDD_MEMORY); ! RETURN_BDD_PAIR(NULL); } *************** *** 169,173 **** bdd_register_pair(p); ! return p; } --- 171,175 ---- bdd_register_pair(p); ! RETURN_BDD_PAIR(p); } *************** *** 196,206 **** int bdd_setpair(bddPair *pair, int oldvar, int newvar) { if (pair == NULL) return 0; if (oldvar < 0 || oldvar > bddvarnum-1) ! return bdd_error(BDD_VAR); if (newvar < 0 || newvar > bddvarnum-1) ! return bdd_error(BDD_VAR); bdd_delref( pair->result[bddvar2level[oldvar]] ); --- 198,213 ---- int bdd_setpair(bddPair *pair, int oldvar, int newvar) { + BUDDY_PROLOGUE; + ADD_ARG1(T_BDD_PAIR,pair); + ADD_ARG1(T_INT,oldvar); + ADD_ARG1(T_INT,newvar); + if (pair == NULL) return 0; if (oldvar < 0 || oldvar > bddvarnum-1) ! RETURN(bdd_error(BDD_VAR)); if (newvar < 0 || newvar > bddvarnum-1) ! RETURN(bdd_error(BDD_VAR)); bdd_delref( pair->result[bddvar2level[oldvar]] ); *************** *** 211,215 **** pair->last = bddvar2level[oldvar]; ! return 0; } --- 218,222 ---- pair->last = bddvar2level[oldvar]; ! RETURN(0); } *************** *** 218,228 **** { int oldlevel; if (pair == NULL) ! return 0; CHECK(newvar); if (oldvar < 0 || oldvar >= bddvarnum) ! return bdd_error(BDD_VAR); oldlevel = bddvar2level[oldvar]; --- 225,240 ---- { int oldlevel; + + BUDDY_PROLOGUE; + ADD_ARG1(T_BDD_PAIR,pair); + ADD_ARG1(T_INT, oldvar); + ADD_ARG1(T_BDD,newvar); if (pair == NULL) ! RETURN(0); CHECK(newvar); if (oldvar < 0 || oldvar >= bddvarnum) ! RETURN(bdd_error(BDD_VAR)); oldlevel = bddvar2level[oldvar]; *************** *** 234,238 **** pair->last = oldlevel; ! return 0; } --- 246,250 ---- pair->last = oldlevel; ! RETURN(0); } *************** *** 253,258 **** { int n,e; if (pair == NULL) ! return 0; for (n=0 ; n<size ; n++) --- 265,277 ---- { int n,e; + + BUDDY_PROLOGUE; + ADD_ARG1(T_BDD_PAIR,pair); + ADD_ARG2(T_INT_PTR,oldvar,size); + ADD_ARG2(T_INT_PTR,newvar,size); + ADD_ARG1(T_INT,size); + if (pair == NULL) ! RETURN(0); for (n=0 ; n<size ; n++) *************** *** 260,264 **** return e; ! return 0; } --- 279,283 ---- return e; ! RETURN(0); } *************** *** 290,296 **** { int n; if (p == NULL) ! return; if (pairs != p) --- 309,318 ---- { int n; + + BUDDY_PROLOGUE; + ADD_ARG1(T_BDD_PAIR,p); if (p == NULL) ! RETURN(); if (pairs != p) *************** *** 306,313 **** --- 328,337 ---- pairs = p->next; + trace_del_bdd(T_BDD_PAIR,p); for (n=0 ; n<bddvarnum ; n++) bdd_delref( p->result[n] ); free(p->result); free(p); + RETURN(); } *************** *** 326,332 **** --- 350,360 ---- int n; + BUDDY_PROLOGUE; + ADD_ARG1(T_BDD_PAIR,p); + for (n=0 ; n<bddvarnum ; n++) p->result[n] = bdd_ithvar(n); p->last = 0; + RETURN(); } Index: kernel.c =================================================================== RCS file: /cvsroot/javabdd/JavaBDD/buddy/src/kernel.c,v retrieving revision 1.1.1.1 retrieving revision 1.2 diff -C2 -d -r1.1.1.1 -r1.2 *** kernel.c 29 Sep 2004 09:50:25 -0000 1.1.1.1 --- kernel.c 29 Sep 2004 10:00:50 -0000 1.2 *************** *** 104,107 **** --- 104,111 ---- bddCacheStat bddcachestats; + int trace_enable = 0; /* Flag indicating whether to trace lib calls */ + int trace_outputted = 0; /* Flag indicating whether the trace file + * has been outputted yet + */ *************** *** 117,120 **** --- 121,127 ---- static bdd2inthandler resize_handler; /* Node-table-resize handler */ + /* Pre-allocate node table */ + static int MAX_ALLOC_NODES = 100000000; + static BddNode* alloced; /* Strings for all error mesages */ *************** *** 175,188 **** { int n, err; srand48( SRAND48SEED ) ; if (bddrunning) ! return bdd_error(BDD_RUNNING); bddnodesize = bdd_prime_gte(initnodesize); ! if ((bddnodes=(BddNode*)malloc(sizeof(BddNode)*bddnodesize)) == NULL) ! return bdd_error(BDD_MEMORY); bddresized = 0; --- 182,215 ---- { int n, err; + char * str; + + + /* Check to see if tracing is enabled */ + + if( (str = getenv("BUDDY_TRACE_FILE")) != NULL) + { + trace_enable = 1; + trace_init(str); + } + + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,initnodesize); + ADD_ARG1(T_INT,cs); srand48( SRAND48SEED ) ; if (bddrunning) ! RETURN(bdd_error(BDD_RUNNING)); bddnodesize = bdd_prime_gte(initnodesize); ! if ((MAX_ALLOC_NODES == 0) || ! (alloced=(BddNode*)malloc(sizeof(BddNode)*MAX_ALLOC_NODES)) == NULL) { ! if ((alloced=(BddNode*)malloc(sizeof(BddNode)*bddnodesize)) == NULL) { ! RETURN(bdd_error(BDD_MEMORY)); ! } ! MAX_ALLOC_NODES = bddnodesize; ! } ! bddnodes = alloced; bddresized = 0; *************** *** 205,209 **** { bdd_done(); ! return err; } --- 232,236 ---- { bdd_done(); ! RETURN(err); } *************** *** 238,242 **** assert(0); ! return 0; } --- 265,269 ---- assert(0); ! RETURN(0); } *************** *** 254,257 **** --- 281,289 ---- { /*sanitycheck(); FIXME */ + + + if(trace_enable) + output_trace(); + bdd_fdd_done(); bdd_reorder_done(); *************** *** 301,304 **** --- 333,339 ---- int oldbddvarnum = bddvarnum; + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,num); + bdd_disable_reorder(); *************** *** 306,325 **** { bdd_error(BDD_RANGE); ! return bddfalse; } if (num < bddvarnum) ! return bdd_error(BDD_DECVNUM); if (num == bddvarnum) ! return 0; if (bddvarset == NULL) { if ((bddvarset=(BDD*)malloc(sizeof(BDD)*num*2)) == NULL) ! return bdd_error(BDD_MEMORY); if ((bddlevel2var=(int*)malloc(sizeof(int)*(num+1))) == NULL) { free(bddvarset); ! return bdd_error(BDD_MEMORY); } if ((bddvar2level=(int*)malloc(sizeof(int)*(num+1))) == NULL) --- 341,360 ---- { bdd_error(BDD_RANGE); ! RETURN(bddfalse); } if (num < bddvarnum) ! RETURN(bdd_error(BDD_DECVNUM)); if (num == bddvarnum) ! RETURN(0); if (bddvarset == NULL) { if ((bddvarset=(BDD*)malloc(sizeof(BDD)*num*2)) == NULL) ! RETURN(bdd_error(BDD_MEMORY)); if ((bddlevel2var=(int*)malloc(sizeof(int)*(num+1))) == NULL) { free(bddvarset); ! RETURN(bdd_error(BDD_MEMORY)); } if ((bddvar2level=(int*)malloc(sizeof(int)*(num+1))) == NULL) *************** *** 327,331 **** free(bddvarset); free(bddlevel2var); ! return bdd_error(BDD_MEMORY); } } --- 362,366 ---- free(bddvarset); free(bddlevel2var); ! RETURN(bdd_error(BDD_MEMORY)); } } *************** *** 333,341 **** { if ((bddvarset=(BDD*)realloc(bddvarset,sizeof(BDD)*num*2)) == NULL) ! return bdd_error(BDD_MEMORY); if ((bddlevel2var=(int*)realloc(bddlevel2var,sizeof(int)*(num+1))) == NULL) { free(bddvarset); ! return bdd_error(BDD_MEMORY); } if ((bddvar2level=(int*)realloc(bddvar2level,sizeof(int)*(num+1))) == NULL) --- 368,376 ---- { if ((bddvarset=(BDD*)realloc(bddvarset,sizeof(BDD)*num*2)) == NULL) ! RETURN(bdd_error(BDD_MEMORY)); if ((bddlevel2var=(int*)realloc(bddlevel2var,sizeof(int)*(num+1))) == NULL) { free(bddvarset); ! RETURN(bdd_error(BDD_MEMORY)); } if ((bddvar2level=(int*)realloc(bddvar2level,sizeof(int)*(num+1))) == NULL) *************** *** 343,347 **** free(bddvarset); free(bddlevel2var); ! return bdd_error(BDD_MEMORY); } } --- 378,382 ---- free(bddvarset); free(bddlevel2var); ! RETURN(bdd_error(BDD_MEMORY)); } } *************** *** 360,364 **** { bddvarnum = bdv; ! return -bdderrorcond; } --- 395,399 ---- { bddvarnum = bdv; ! RETURN(-bdderrorcond); } *************** *** 376,383 **** bdd_pairs_resize(oldbddvarnum, bddvarnum); bdd_operator_varresize(); ! bdd_enable_reorder(); ! ! return 0; } --- 411,418 ---- bdd_pairs_resize(oldbddvarnum, bddvarnum); bdd_operator_varresize(); ! bdd_enable_reorder(); ! ! RETURN(0); } *************** *** 396,405 **** { int start = bddvarnum; if (num < 0 || num > 0x3FFFFFFF) ! return bdd_error(BDD_RANGE); bdd_setvarnum(bddvarnum+num); ! return start; } --- 431,443 ---- { int start = bddvarnum; + + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,num); if (num < 0 || num > 0x3FFFFFFF) ! RETURN(bdd_error(BDD_RANGE)); bdd_setvarnum(bddvarnum+num); ! RETURN(start); } *************** *** 435,439 **** --- 473,479 ---- { bddinthandler tmp = err_handler; + BUDDY_IGNOREFN_PROLOGUE; err_handler = handler; + BUDDY_IGNOREFN_EPILOGUE; return tmp; } *************** *** 457,462 **** --- 497,504 ---- void bdd_clear_error(void) { + BUDDY_PROLOGUE; bdderrorcond = 0; bdd_operator_reset(); + RETURN(); } *************** *** 546,555 **** { int old = bddmaxnodeincrease; if (size < 0) ! return bdd_error(BDD_SIZE); bddmaxnodeincrease = size; ! return old; } --- 588,600 ---- { int old = bddmaxnodeincrease; + + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,size); if (size < 0) ! RETURN(bdd_error(BDD_SIZE)); bddmaxnodeincrease = size; ! RETURN(old); } *************** *** 573,584 **** int bdd_setmaxnodenum(int size) { if (size > bddnodesize || size == 0) { int old = bddmaxnodesize; bddmaxnodesize = size; ! return old; } ! return bdd_error(BDD_NODES); } --- 618,632 ---- int bdd_setmaxnodenum(int size) { + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,size); + if (size > bddnodesize || size == 0) { int old = bddmaxnodesize; bddmaxnodesize = size; ! RETURN(old); } ! RETURN(bdd_error(BDD_NODES)); } *************** *** 605,614 **** { int old = minfreenodes; if (mf<0 || mf>100) ! return bdd_error(BDD_RANGE); minfreenodes = mf; ! return old; } --- 653,665 ---- { int old = minfreenodes; + + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,mf); if (mf<0 || mf>100) ! RETURN(bdd_error(BDD_RANGE)); minfreenodes = mf; ! RETURN(old); } *************** *** 628,632 **** int bdd_getnodenum(void) { ! return bddnodesize - bddfreenum; } --- 679,684 ---- int bdd_getnodenum(void) { ! BUDDY_PROLOGUE; ! RETURN(bddnodesize - bddfreenum); } *************** *** 644,648 **** int bdd_getallocnum(void) { ! return bddnodesize; } --- 696,701 ---- int bdd_getallocnum(void) { ! BUDDY_PROLOGUE; ! RETURN(bddnodesize); } *************** *** 660,666 **** int bdd_isrunning(void) { ! return bddrunning; } /* --- 713,726 ---- int bdd_isrunning(void) { ! BUDDY_PROLOGUE; ! RETURN(bddrunning); } + #ifndef VERSION + #define VERSION (MAJOR_VERSION*10+MINOR_VERSION) + #endif + #ifndef PACKAGE_VERSION + #define PACKAGE_VERSION "VERSION" + #endif /* *************** *** 676,680 **** { static char str[] = "BuDDy - release " PACKAGE_VERSION; ! return str; } --- 736,741 ---- { static char str[] = "BuDDy - release " PACKAGE_VERSION; ! BUDDY_PROLOGUE; ! RETURN(str); } *************** *** 691,695 **** int bdd_versionnum(void) { ! return MAJOR_VERSION * 10 + MINOR_VERSION; } --- 752,757 ---- int bdd_versionnum(void) { ! BUDDY_PROLOGUE; ! RETURN(MAJOR_VERSION * 10 + MINOR_VERSION); } *************** *** 778,782 **** --- 840,846 ---- void bdd_printstat(void) { + BUDDY_PROLOGUE; bdd_fprintstat(stdout); + RETURN(); } *************** *** 798,805 **** const char *bdd_errstring(int e) { e = abs(e); if (e<1 || e>BDD_ERRNUM) ! return NULL; ! return errorstrings[e-1]; } --- 862,872 ---- const char *bdd_errstring(int e) { + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,e); + e = abs(e); if (e<1 || e>BDD_ERRNUM) ! RETURN(NULL); ! RETURN(errorstrings[e-1]); } *************** *** 814,821 **** int bdd_error(int e) { if (err_handler != NULL) err_handler(e); ! return e; } --- 881,889 ---- int bdd_error(int e) { + BUDDY_PROLOGUE; if (err_handler != NULL) err_handler(e); ! RETURN(e); } *************** *** 838,842 **** BDD bdd_true(void) { ! return 1; } --- 906,911 ---- BDD bdd_true(void) { ! BUDDY_PROLOGUE; ! RETURN_BDD(1); } *************** *** 855,859 **** BDD bdd_false(void) { ! return 0; } --- 924,929 ---- BDD bdd_false(void) { ! BUDDY_PROLOGUE; ! RETURN_BDD(0); } *************** *** 878,888 **** BDD bdd_ithvar(int var) { if (var < 0 || var >= bddvarnum) { bdd_error(BDD_VAR); ! return bddfalse; } ! return bddvarset[var*2]; } --- 948,960 ---- BDD bdd_ithvar(int var) { + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,var); if (var < 0 || var >= bddvarnum) { bdd_error(BDD_VAR); ! RETURN_BDD(bddfalse); } ! RETURN_BDD(bddvarset[var*2]); } *************** *** 904,914 **** BDD bdd_nithvar(int var) { if (var < 0 || var >= bddvarnum) { bdd_error(BDD_VAR); ! return bddfalse; } ! return bddvarset[var*2+1]; } --- 976,988 ---- BDD bdd_nithvar(int var) { + BUDDY_PROLOGUE; + ADD_ARG1(T_INT,var); if (var < 0 || var >= bddvarnum) { bdd_error(BDD_VAR); ! RETURN_BDD(bddfalse); } ! RETURN_BDD(bddvarset[var*2+1]); } *************** *** 926,930 **** int bdd_varnum(void) { ! return bddvarnum; } --- 1000,1005 ---- int bdd_varnum(void) { ! BUDDY_PROLOGUE; ! RETURN(bddvarnum); } *************** *** 940,948 **** int bdd_var(BDD root) { CHECK(root); if (root < 2) ! return bdd_error(BDD_ILLBDD); ! return (bddlevel2var[LEVEL(root)]); } --- 1015,1026 ---- int bdd_var(BDD root) { + BUDDY_PROLOGUE; + ADD_ARG1(T_BDD,root); + CHECK(root); if (root < 2) ! RETURN(bdd_error(BDD_ILLBDD)); ! RETURN(bddlevel2var[LEVEL(root)]); } *************** *** 959,967 **** BDD bdd_low(BDD root) { CHECK(root); if (root < 2) ! return bdd_error(BDD_ILLBDD); ! return (LOW(root)); } --- 1037,1048 ---- BDD bdd_low(BDD root) { + BUDDY_PROLOGUE; + ADD_ARG1(T_BDD,root); + CHECK(root); if (root < 2) ! RETURN_BDD(bdd_error(BDD_ILLBDD)); ! RETURN_BDD(LOW(root)); } *************** *** 978,986 **** BDD bdd_high(BDD root) { CHECK(root); if (root < 2) ! return bdd_error(BDD_ILLBDD); ! return (HIGH(root)); } --- 1059,1070 ---- BDD bdd_high(BDD root) { + BUDDY_PROLOGUE; + ADD_ARG1(T_BDD,root); + CHECK(root); if (root < 2) ! RETURN_BDD(bdd_error(BDD_ILLBDD)); ! RETURN_BDD(HIGH(root)); } *************** *** 1118,1130 **** BDD bdd_addref(BDD root) { if (root < 2 || !bddrunning) ! return root; if (root >= bddnodesize) ! return bdd_error(BDD_ILLBDD); if (LOW(root) == -1) ! return bdd_error(BDD_ILLBDD); INCREF(root); ! return root; } --- 1202,1217 ---- BDD bdd_addref(BDD root) { + BUDDY_PROLOGUE; + ADD_ARG1(T_BDD,root); + if (root < 2 || !bddrunning) ! RETURN_BDD(root); if (root >= bddnodesize) ! RETURN_BDD(bdd_error(BDD_ILLBDD)); if (LOW(root) == -1) ! RETURN_BDD(bdd_error(BDD_ILLBDD)); INCREF(root); ! RETURN_BDD(root); } *************** *** 1144,1159 **** BDD bdd_delref(BDD root) { if (root < 2 || !bddrunning) ! return root; if (root >= bddnodesize) ! return bdd_error(BDD_ILLBDD); if (LOW(root) == -1) ! return bdd_error(BDD_ILLBDD); /* if the following line is present, fails there much earlier */ ! if (!HASREF(root)) bdd_error(BDD_BREAK); /* distinctive */ DECREF(root); ! return root; } --- 1231,1251 ---- BDD bdd_delref(BDD root) { + BUDDY_PROLOGUE; + ADD_ARG1(T_BDD,root); if (root < 2 || !bddrunning) ! RETURN_BDD(root); if (root >= bddnodesize) ! RETURN_BDD(bdd_error(BDD_ILLBDD)); if (LOW(root) == -1) ! RETURN_BDD(bdd_error(BDD_ILLBDD)); /* if the following line is present, fails there much earlier */ ! if (!HASREF(root)) ! bdd_error(BDD_BREAK); /* distinctive */ DECREF(root); ! if(!HASREF(root)) ! trace_del_bdd(T_BDD,(void *)root); ! RETURN_BDD(root); } *************** *** 1370,1377 **** resize_handler(oldsize, bddnodesize); ! newnodes = (BddNode*)realloc(bddnodes, sizeof(BddNode)*bddnodesize); ! if (newnodes == NULL) ! return bdd_error(BDD_MEMORY); ! bddnodes = newnodes; if (doRehash) --- 1462,1474 ---- resize_handler(oldsize, bddnodesize); ! if (bddnodesize > MAX_ALLOC_NODES) { ! alloced = (BddNode*)realloc(alloced, sizeof(BddNode)*bddnodesize); ! if (alloced == NULL) ! return bdd_error(BDD_MEMORY); ! bddnodes = alloced; ! MAX_ALLOC_NODES = bddnodesize; ! } else { ! bddnodes = alloced; ! } if (doRehash) *************** *** 1480,1483 **** --- 1577,1584 ---- { int v, res=1; + + BUDDY_PROLOGUE; + ADD_ARG2(T_INT_PTR,varset,varnum); + ADD_ARG1(T_INT,varnum); for (v=varnum-1 ; v>=0 ; v--) *************** *** 1490,1494 **** } ! return res; } --- 1591,1595 ---- } ! RETURN_BDD(res); } --- NEW FILE: trace.h --- #include <stdlib.h> #include <assert.h> #ifdef GENERATE_TRACE #define BUDDY_PROLOGUE \ int was_enabled = trace_enable; \ if(was_enabled) \ trace_begin_function(__func__); \ trace_enable=0 #define BUDDY_IGNOREFN_PROLOGUE int was_enabled = trace_enable;trace_enable = 0 #define BUDDY_IGNOREFN_EPILOGUE trace_enable = was_enabled #define ADD_ARG1(type,expr) if(was_enabled) trace_add_arg(type,(void *)expr, NULL) #define ADD_ARG2(type,expr1,expr2) if(was_enabled) trace_add_arg(type,(void *)expr1, (void *)expr2) #define RETURN_BDD(expr) \ if(was_enabled) \ { \ trace_enable = 1; \ return (BDD) trace_end_function_bdd(T_BDD,(void *)expr); \ } else return expr; #define RETURN_BDD_PAIR(expr) \ if(was_enabled) \ { \ trace_enable = 1; \ return (bddPair *) trace_end_function_bdd(T_BDD_PAIR,(void *)expr); \ } else return expr; #define RETURN(expr) \ do \ { \ if(was_enabled) \ {\ trace_enable = 1; \ trace_end_function(); \ } \ return expr; \ } while(0) enum arg_type { T_INT, T_INT_PTR, T_CHAR_PTR, T_BDD, T_BDD_PTR, T_BDD_LOAD, T_BDD_PAIR }; static __inline__ void * xmalloc(int sz) { void * retval = malloc(sz); assert(retval); return retval; } void trace_init(const char *filename); void trace_add_bdd(enum arg_type type,void * val); void trace_del_bdd(enum arg_type type, void * val); void trace_begin_function(const char * fn); void trace_end_function(void); void * trace_end_function_bdd(enum arg_type type, void * arg); void trace_add_arg(enum arg_type type, void * arg1, void * arg2); void output_trace(void); extern int trace_enable; extern int trace_outputted; #else // GENERATE_TRACE #define BUDDY_PROLOGUE do { } while (0); #define BUDDY_IGNOREFN_PROLOGUE do { } while (0); #define BUDDY_IGNOREFN_EPILOGUE do { } while (0); #define ADD_ARG1(type,expr) do { } while (0); #define ADD_ARG2(type,expr1,expr2) do { } while (0); #define RETURN_BDD(expr) do { return expr; } while (0); #define RETURN_BDD_PAIR(expr) do { return expr; } while (0); #define RETURN(expr) do { return expr; } while (0); #define trace_init(filename) do { } while (0); #define trace_del_bdd(type,val) do { } while (0); #define output_trace() do { } while (0); #endif // !GENERATE_TRACE Index: bdd.h =================================================================== RCS file: /cvsroot/javabdd/JavaBDD/buddy/src/bdd.h,v retrieving revision 1.1.1.1 retrieving revision 1.2 diff -C2 -d -r1.1.1.1 -r1.2 *** bdd.h 29 Sep 2004 09:50:25 -0000 1.1.1.1 --- bdd.h 29 Sep 2004 10:00:49 -0000 1.2 *************** *** 81,85 **** } bddPair; - /*=== Status information ===============================================*/ --- 81,84 ---- *************** *** 412,415 **** --- 411,416 ---- #define BDD_ERRNUM 24 + #include "trace.h" + /************************************************************************* If this file is included from a C++ compiler then the following *************** *** 823,826 **** --- 824,829 ---- extern bdd_ioformat fddset; + extern int trace_enable; + typedef void (*bddstrmhandler)(std::ostream &, int); |
