src/calBdd/calPerformanceTest.c File Reference

#include "calInt.h"
#include <unistd.h>
#include <sys/types.h>
Include dependency graph for calPerformanceTest.c:

Go to the source code of this file.

Functions

static void CalPerformanceTestAnd (Cal_BddManager bddManager, Cal_Bdd *outputBddArray, int numFunctions)
static void CalPerformaceTestSuperscalar (Cal_BddManager bddManager, Cal_Bdd *outputBddArray, int numFunctions)
static void CalPerformanceTestNonSuperscalar (Cal_BddManager bddManager, Cal_Bdd *outputBddArray, int numFunctions)
static void CalPerformanceTestMultiway (Cal_BddManager bddManager, Cal_Bdd *outputBddArray, int numFunctions)
static void CalPerformanceTestOneway (Cal_BddManager bddManager, Cal_Bdd *outputBddArray, int numFunctions)
static void CalPerformanceTestCompose (Cal_BddManager bddManager, Cal_Bdd *outputBddArray, int numFunctions)
static void CalPerformanceTestQuantifyAllTogether (Cal_BddManager bddManager, Cal_Bdd *outputBddArray, int numFunctions, int bfZeroBFPlusDFOne, int cacheExistsResultsFlag, int cacheOrResultsFlag)
static void CalQuantifySanityCheck (Cal_BddManager bddManager, Cal_Bdd *outputBddArray, int numFunctions)
static void CalPerformanceTestRelProd (Cal_BddManager bddManager, Cal_Bdd *outputBddArray, int numFunctions, int bfZeroBFPlusDFOne, int cacheRelProdResultsFlag, int cacheAndResultsFlag, int cacheOrResultsFlag)
static void CalPerformanceTestSubstitute (Cal_BddManager bddManager, Cal_Bdd *outputBddArray, int numFunctions)
static void CalPerformanceTestSwapVars (Cal_BddManager bddManager, Cal_Bdd *outputBddArray, int numFunctions)
static long elapsedTime (void)
static double cpuTime (void)
static long pageFaults (void)
static void GetRandomNumbers (int lowerBound, int upperBound, int count, int *resultVector)
int Cal_PerformanceTest (Cal_BddManager bddManager, Cal_Bdd *outputBddArray, int numFunctions, int iteration, int seed, int andPerformanceFlag, int multiwayPerformanceFlag, int onewayPerformanceFlag, int quantifyPerformanceFlag, int composePerformanceFlag, int relprodPerformanceFlag, int swapPerformanceFlag, int substitutePerformanceFlag, int sanityCheckFlag, int computeMemoryOverheadFlag, int superscalarFlag)
int CalIncreasingOrderCompare (const void *a, const void *b)
int CalDecreasingOrderCompare (const void *a, const void *b)

Variables

static int ITERATION

Function Documentation

int Cal_PerformanceTest ( Cal_BddManager  bddManager,
Cal_Bdd *  outputBddArray,
int  numFunctions,
int  iteration,
int  seed,
int  andPerformanceFlag,
int  multiwayPerformanceFlag,
int  onewayPerformanceFlag,
int  quantifyPerformanceFlag,
int  composePerformanceFlag,
int  relprodPerformanceFlag,
int  swapPerformanceFlag,
int  substitutePerformanceFlag,
int  sanityCheckFlag,
int  computeMemoryOverheadFlag,
int  superscalarFlag 
)

AutomaticEnd Function********************************************************************

Synopsis [Main routine for testing performances of various routines.]

Description [optional]

SideEffects [required]

SeeAlso [optional]

Definition at line 114 of file calPerformanceTest.c.

00125 {
00126   
00127   CalUtilSRandom((long)seed);
00128   
00129   ITERATION = iteration;
00130   fprintf(stdout,"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");
00131   fprintf(stdout, "Performing %d iterations for each function\n", iteration);
00132   Cal_BddSetGCMode(bddManager, 0);
00133 #ifdef QUANTIFY
00134   quantify_start_recording_data();
00135 #endif
00136 
00137 #ifdef PURECOV
00138         purecov_clear_data();
00139 #endif
00140 
00141   if (relprodPerformanceFlag){
00142     CalPerformanceTestRelProd(bddManager, outputBddArray, numFunctions, 1, 1,
00143                               1, 1);
00144     CalUtilSRandom((long)seed);
00145 
00146   }
00147   if (sanityCheckFlag == 1){
00148     CalQuantifySanityCheck(bddManager, outputBddArray,
00149                            numFunctions);
00150     CalUtilSRandom((long)seed);
00151   }
00152   if (quantifyPerformanceFlag){
00153     CalPerformanceTestQuantifyAllTogether(bddManager, outputBddArray,
00154                                           numFunctions, 1, 1, 1);
00155     CalUtilSRandom((long)seed);
00156         /*
00157     CalPerformanceTestNonSuperscalarQuant(bddManager, outputBddArray, numFunctions);
00158     CalUtilSRandom((long)seed);
00159         */
00160   }
00161 
00162   if (multiwayPerformanceFlag){
00163     CalPerformanceTestMultiway(bddManager, outputBddArray, numFunctions); 
00164     CalUtilSRandom((long)seed);
00165   }
00166   if (onewayPerformanceFlag){
00167     CalPerformanceTestOneway(bddManager, outputBddArray, numFunctions);
00168     CalUtilSRandom((long)seed);
00169   }
00170   if (andPerformanceFlag){
00171     CalPerformanceTestAnd(bddManager, outputBddArray, numFunctions); 
00172     CalUtilSRandom((long)seed);
00173   }
00174   if (composePerformanceFlag){
00175     CalPerformanceTestCompose(bddManager, outputBddArray, numFunctions);
00176     CalUtilSRandom((long)seed);
00177   }
00178   if (swapPerformanceFlag){
00179     CalPerformanceTestSwapVars(bddManager, outputBddArray, numFunctions);
00180     CalUtilSRandom((long)seed);
00181   }
00182   if (substitutePerformanceFlag){
00183     CalPerformanceTestSubstitute(bddManager, outputBddArray, numFunctions);
00184     CalUtilSRandom((long)seed);
00185   }
00186 #ifdef COMPUTE_MEMORY_OVERHEAD
00187   if (computeMemoryOverheadFlag){
00188     CalPerformaceMemoryOverhead(bddManager, outputBddArray, numFunctions);
00189     CalUtilSRandom((long)seed);
00190   }
00191 #endif
00192   if (superscalarFlag){
00193     CalPerformaceTestSuperscalar(bddManager, outputBddArray, numFunctions);
00194     CalUtilSRandom((long)seed);
00195     CalPerformanceTestNonSuperscalar(bddManager, outputBddArray, numFunctions);
00196     CalUtilSRandom((long)seed);
00197   }
00198 #ifdef QUANTIFY
00199   quantify_stop_recording_data();
00200 #endif
00201 #ifdef PURECOV
00202         purecov_save_data();
00203         purecov_disable_save();
00204 #endif
00205   fprintf(stdout,"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");
00206   Cal_BddSetGCMode(bddManager, 1);
00207   return 0;
00208 }

int CalDecreasingOrderCompare ( const void *  a,
const void *  b 
)

Function********************************************************************

Synopsis [required]

Description [optional]

SideEffects [required]

SeeAlso [optional]

Definition at line 241 of file calPerformanceTest.c.

00242 {
00243   return (*(int *)a-*(int *)b);
00244 }

int CalIncreasingOrderCompare ( const void *  a,
const void *  b 
)

Function********************************************************************

Synopsis [required]

Description [optional]

SideEffects [required]

SeeAlso [optional]

Definition at line 224 of file calPerformanceTest.c.

00225 {
00226   return (*(int *)b-*(int *)a);
00227 }

static void CalPerformaceTestSuperscalar ( Cal_BddManager  bddManager,
Cal_Bdd *  outputBddArray,
int  numFunctions 
) [static]

Function********************************************************************

Synopsis [Performance test routine for quantify (all variables at the same time).]

Description [optional]

SideEffects [required]

SeeAlso [optional]

Definition at line 379 of file calPerformanceTest.c.

00381 {
00382   int i,j;
00383   Cal_Bdd *bddArray, *resultArray;
00384   int *varIdArray;
00385   int num = (((numFunctions%2) == 0)? numFunctions : (numFunctions-1));
00386   if (num == 0) return;
00387   if (num > 100) num = 100;
00388   varIdArray = Cal_MemAlloc(int, num);
00389   bddArray = Cal_MemAlloc(Cal_Bdd, num+1);
00390   bddArray[num] = (Cal_Bdd) 0;
00391   
00392   
00393   (void) elapsedTime();
00394   cpuTime();
00395   pageFaults();
00396   for (i=0; i<ITERATION; i++){
00397     GetRandomNumbers(0, numFunctions-1, num, varIdArray);
00398     for (j=0; j<num; j++){
00399       bddArray[j] = outputBddArray[varIdArray[j]];
00400     }
00401     resultArray = Cal_BddPairwiseAnd(bddManager, bddArray);
00402     for (j=0; j<num/2; j++){
00403       Cal_BddFree(bddManager, resultArray[j]);
00404     }
00405     Cal_MemFree(resultArray);
00406   }
00407   fprintf(stdout, "%-20s%-10ld%-8.2f%-10ld\n", "SUPERSCALARAND", elapsedTime(),
00408           cpuTime(), pageFaults());
00409   Cal_MemFree(varIdArray);
00410   Cal_MemFree(bddArray);
00411   Cal_BddManagerGC(bddManager);
00412 }

static void CalPerformanceTestAnd ( Cal_BddManager  bddManager,
Cal_Bdd *  outputBddArray,
int  numFunctions 
) [static]

AutomaticStart

Function********************************************************************

Synopsis [Performance test routine for quantify (all variables at the same time).]

Description [optional]

SideEffects [required]

SeeAlso [optional]

Definition at line 261 of file calPerformanceTest.c.

00263 {
00264   int i;
00265   Cal_Bdd function1, function2;
00266   Cal_Bdd result;
00267   
00268   
00269   (void) elapsedTime();
00270   cpuTime();
00271   pageFaults();
00272   for (i=0; i<ITERATION; i++){
00273     function1 = outputBddArray[CalUtilRandom()%numFunctions];
00274     function2 = outputBddArray[CalUtilRandom()%numFunctions];
00275     result = Cal_BddAnd(bddManager, function1, function2);
00276     Cal_BddFree(bddManager, result);
00277   }
00278   fprintf(stdout, "%-20s%-10ld%-8.2f%-10ld\n", "AND", elapsedTime(),
00279           cpuTime(), pageFaults());
00280   Cal_BddManagerGC(bddManager);
00281 }

static void CalPerformanceTestCompose ( Cal_BddManager  bddManager,
Cal_Bdd *  outputBddArray,
int  numFunctions 
) [static]

Function********************************************************************

Synopsis [Performance test routine for quantify (all variables at the same time).]

Description [optional]

SideEffects [required]

SeeAlso [optional]

Definition at line 575 of file calPerformanceTest.c.

00577 {
00578   int i;
00579   int numVars = Cal_BddVars(bddManager);
00580   Cal_Bdd function;
00581   Cal_Bdd variable;
00582   Cal_Bdd substituteFunction;
00583   Cal_Bdd result;
00584   
00585   
00586   (void) elapsedTime();
00587   cpuTime();
00588   pageFaults();
00589   for (i=0; i<ITERATION; i++){
00590     function = outputBddArray[CalUtilRandom()%numFunctions];
00591     variable = Cal_BddManagerGetVarWithId(bddManager,(Cal_BddId_t)CalUtilRandom()%numVars+1);
00592     substituteFunction = outputBddArray[CalUtilRandom()%numFunctions];
00593     result = Cal_BddCompose(bddManager, function, variable,
00594                                     substituteFunction);
00595     Cal_BddFree(bddManager, result);
00596   }
00597   fprintf(stdout, "%-20s%-10ld%-8.2f%-10ld\n", "COMPOSE", elapsedTime(),
00598           cpuTime(), pageFaults());
00599   Cal_BddManagerGC(bddManager);
00600 }

static void CalPerformanceTestMultiway ( Cal_BddManager  bddManager,
Cal_Bdd *  outputBddArray,
int  numFunctions 
) [static]

Function********************************************************************

Synopsis [Performance test routine for quantify (all variables at the same time).]

Description [optional]

SideEffects [required]

SeeAlso [optional]

Definition at line 480 of file calPerformanceTest.c.

00482 {
00483   int i,j;
00484   Cal_Bdd result, *bddArray;
00485   int *varIdArray;
00486   int power;
00487   int num;
00488   
00489   if (numFunctions <= 1) return;
00490   for (power = 1; power <= 5; power++){
00491     num = (1<<power);
00492     if (num > numFunctions) return;
00493     varIdArray = Cal_MemAlloc(int, num);
00494     bddArray = Cal_MemAlloc(Cal_Bdd, num+1);
00495     bddArray[num] = (Cal_Bdd) 0;
00496     (void) elapsedTime();
00497     cpuTime();
00498     pageFaults();
00499     for (i=0; i<ITERATION; i++){
00500       GetRandomNumbers(0, numFunctions-1, num, varIdArray);
00501       for (j=0; j<num; j++){
00502         bddArray[j] = outputBddArray[varIdArray[j]];
00503       }
00504       result = Cal_BddMultiwayAnd(bddManager, bddArray);
00505       Cal_BddFree(bddManager, result);
00506     }
00507     fprintf(stdout, "%-20s%-4d%-10ld%-8.2f%-10ld\n", "MULTIWAYAND", num,
00508             elapsedTime(), cpuTime(), pageFaults());
00509     Cal_MemFree(varIdArray);
00510     Cal_MemFree(bddArray);
00511     Cal_BddManagerGC(bddManager);
00512   }
00513 }

static void CalPerformanceTestNonSuperscalar ( Cal_BddManager  bddManager,
Cal_Bdd *  outputBddArray,
int  numFunctions 
) [static]

Function********************************************************************

Synopsis [Performance test routine for quantify (all variables at the same time).]

Description [optional]

SideEffects [required]

SeeAlso [optional]

Definition at line 427 of file calPerformanceTest.c.

00429 {
00430   int i, j;
00431   Cal_Bdd *bddArray, *resultArray;
00432   int *varIdArray;
00433 
00434   int num = (((numFunctions%2) == 0)? numFunctions : (numFunctions-1));
00435 
00436   if (num == 0) return;
00437   if (num > 100) num = 100;
00438 
00439   varIdArray = Cal_MemAlloc(int, num);
00440   bddArray = Cal_MemAlloc(Cal_Bdd, num+1);
00441   bddArray[num] = (Cal_Bdd) 0;
00442   resultArray = Cal_MemAlloc(Cal_Bdd, num/2);
00443   
00444   (void) elapsedTime();
00445   cpuTime();
00446   pageFaults();
00447   for (i=0; i<ITERATION; i++){
00448     GetRandomNumbers(0, numFunctions-1, num, varIdArray);
00449     for (j=0; j<num/2; j++){
00450       resultArray[j] = Cal_BddAnd(bddManager,
00451                           outputBddArray[varIdArray[j<<1]],
00452                           outputBddArray[varIdArray[(j<<1)+1]]);  
00453     }
00454     for (j=0; j<num/2; j++){
00455       Cal_BddFree(bddManager, resultArray[j]);
00456     }
00457   }
00458   fprintf(stdout, "%-20s%-10ld%-8.2f%-10ld\n", "NONSUPERSCALARAND", elapsedTime(),
00459           cpuTime(), pageFaults());
00460   Cal_MemFree(resultArray);
00461   Cal_MemFree(bddArray);
00462   Cal_MemFree(varIdArray);
00463   Cal_BddManagerGC(bddManager);
00464 }

static void CalPerformanceTestOneway ( Cal_BddManager  bddManager,
Cal_Bdd *  outputBddArray,
int  numFunctions 
) [static]

Function********************************************************************

Synopsis [Performance test routine for quantify (all variables at the same time).]

Description [optional]

SideEffects [required]

SeeAlso [optional]

Definition at line 528 of file calPerformanceTest.c.

00530 {
00531   int i, j;
00532   Cal_Bdd result, tempResult;
00533   int *varIdArray;
00534   int power, num;
00535   
00536   if (numFunctions <= 1) return;
00537   
00538   for (power = 1; power <= 5; power++){
00539     num = (1<<power);
00540     if (num > numFunctions) return;
00541     varIdArray = Cal_MemAlloc(int, num);
00542     (void) elapsedTime();
00543     cpuTime();
00544     pageFaults();
00545     for (i=0; i<ITERATION; i++){
00546       GetRandomNumbers(0, numFunctions-1, num, varIdArray);
00547       result = Cal_BddOne(bddManager);
00548       for (j=0; j<num; j++){
00549         tempResult = Cal_BddAnd(bddManager, result,
00550                                 outputBddArray[varIdArray[j]]); 
00551         Cal_BddFree(bddManager, result);
00552         result = tempResult;
00553       }
00554       Cal_BddFree(bddManager, result);
00555     }
00556     fprintf(stdout, "%-20s%-4d%-10ld%-8.2f%-10ld\n", "ONEWAYAND", num,
00557             elapsedTime(), cpuTime(), pageFaults());
00558     Cal_MemFree(varIdArray);
00559     Cal_BddManagerGC(bddManager);
00560   }
00561 }

static void CalPerformanceTestQuantifyAllTogether ( Cal_BddManager  bddManager,
Cal_Bdd *  outputBddArray,
int  numFunctions,
int  bfZeroBFPlusDFOne,
int  cacheExistsResultsFlag,
int  cacheOrResultsFlag 
) [static]

Function********************************************************************

Synopsis [Performance test routine for quantify (all variables at the same time).]

Description [optional]

SideEffects [required]

SeeAlso [optional]

Definition at line 614 of file calPerformanceTest.c.

00619 {
00620   int i, j;
00621   int numVars = Cal_BddVars(bddManager);
00622   int numQuantifyVars = numVars/2;
00623   int *varIdArray = Cal_MemAlloc(int, numQuantifyVars);
00624   Cal_Bdd *assoc = Cal_MemAlloc(Cal_Bdd, numQuantifyVars+1);
00625   Cal_Bdd function, result;
00626   int assocId;
00627   
00628   for (i=0; i <= numQuantifyVars; i++){
00629     assoc[i] = (Cal_Bdd) 0;
00630   }
00631   
00632   (void) elapsedTime();
00633   cpuTime();
00634   pageFaults();
00635   for (i=0; i<ITERATION; i++){
00636     function = outputBddArray[CalUtilRandom()%numFunctions];
00637     GetRandomNumbers(1, numVars, numQuantifyVars, varIdArray);
00638     for (j=0; j<numQuantifyVars; j++){
00639       assoc[j] = Cal_BddManagerGetVarWithId(bddManager, varIdArray[j]);
00640     }
00641     assocId = Cal_AssociationInit(bddManager, assoc, 0);
00642     Cal_AssociationSetCurrent(bddManager, assocId);
00643     result = Cal_BddExists(bddManager, function);
00644     Cal_BddFree(bddManager, result); 
00645   }
00646   fprintf(stdout, "%-20s%-10ld%-8.2f%-10ld\n", "QUANTIFY", elapsedTime(),
00647           cpuTime(), pageFaults());
00648   Cal_MemFree(assoc);
00649   Cal_MemFree(varIdArray);
00650   Cal_BddManagerGC(bddManager);
00651 }

static void CalPerformanceTestRelProd ( Cal_BddManager  bddManager,
Cal_Bdd *  outputBddArray,
int  numFunctions,
int  bfZeroBFPlusDFOne,
int  cacheRelProdResultsFlag,
int  cacheAndResultsFlag,
int  cacheOrResultsFlag 
) [static]

Function********************************************************************

Synopsis [Performance test routine for quantify (all variables at the same time).]

Description [optional]

SideEffects [required]

SeeAlso [optional]

Definition at line 735 of file calPerformanceTest.c.

00739 {
00740   int i, j;
00741   int numVars = Cal_BddVars(bddManager);
00742   int numQuantifyVars = numVars/2;
00743   int *varIdArray = Cal_MemAlloc(int, numQuantifyVars);
00744   Cal_Bdd *assoc = Cal_MemAlloc(Cal_Bdd, numQuantifyVars+1);
00745   Cal_Bdd function1, function2, result;
00746   int assocId;
00747   
00748   for (i=0; i <= numQuantifyVars; i++){
00749     assoc[i] = (Cal_Bdd) 0;
00750   }
00751   
00752   elapsedTime();
00753   cpuTime();
00754   pageFaults();
00755   for (i=0; i<ITERATION; i++){
00756     function1 = outputBddArray[CalUtilRandom()%numFunctions];
00757     function2 = outputBddArray[CalUtilRandom()%numFunctions]; 
00758    GetRandomNumbers(1, numVars, numQuantifyVars,varIdArray);
00759     for (j=0; j<numQuantifyVars; j++){
00760       assoc[j] = Cal_BddManagerGetVarWithId(bddManager, varIdArray[j]);
00761     }
00762     assocId = Cal_AssociationInit(bddManager, assoc, 0);
00763     Cal_AssociationSetCurrent(bddManager, assocId);
00764     result = Cal_BddRelProd(bddManager, function1, function2);
00765     Cal_BddFree(bddManager, result);
00766   }
00767   fprintf(stdout, "%-20s%-10ld%-8.2f%-10ld\n", "RELPROD", elapsedTime(),
00768           cpuTime(), pageFaults());
00769   Cal_MemFree(assoc);
00770   Cal_MemFree(varIdArray);
00771   Cal_BddManagerGC(bddManager);
00772 }

static void CalPerformanceTestSubstitute ( Cal_BddManager  bddManager,
Cal_Bdd *  outputBddArray,
int  numFunctions 
) [static]

Function********************************************************************

Synopsis [Performance test routine for quantify (all variables at the same time).]

Description [optional]

SideEffects [required]

SeeAlso [optional]

Definition at line 788 of file calPerformanceTest.c.

00790 {
00791   int i, j;
00792   int numVars = Cal_BddVars(bddManager);
00793   int numQuantifyVars = ((numVars/2 > numFunctions/2) ? numFunctions/2
00794                          : numVars/2);
00795   int *varIdArray = Cal_MemAlloc(int, numQuantifyVars);
00796   Cal_Bdd *assoc = Cal_MemAlloc(Cal_Bdd, 2*numQuantifyVars+1);
00797   Cal_Bdd function, result;
00798   
00799   for (i=0; i <= 2*numQuantifyVars; i++){
00800     assoc[i] = (Cal_Bdd) 0;
00801   }
00802   (void) elapsedTime();
00803   cpuTime();
00804   pageFaults();
00805   for (i=0; i<ITERATION/5; i++){
00806     function = outputBddArray[CalUtilRandom()%numFunctions];
00807     GetRandomNumbers(1, numVars, numQuantifyVars,varIdArray);
00808     for (j=0; j<numQuantifyVars; j++){
00809       assoc[(j<<1)] = Cal_BddManagerGetVarWithId(bddManager,varIdArray[j]);
00810     }
00811     GetRandomNumbers(0, numFunctions-1, numQuantifyVars, varIdArray);
00812     for (j=0; j<numQuantifyVars; j++){
00813       assoc[(j<<1)+1] = outputBddArray[varIdArray[j]];
00814     }
00815     Cal_TempAssociationInit(bddManager, assoc, 1);
00816     Cal_AssociationSetCurrent(bddManager, -1);
00817     result = Cal_BddSubstitute(bddManager, function);
00818     Cal_BddFree(bddManager, result);
00819   }
00820   fprintf(stdout, "%-20s%-10ld%-8.2f%-10ld\n", "SUBSTITUTE", elapsedTime(),
00821           cpuTime(), pageFaults());
00822   Cal_MemFree(assoc);
00823   Cal_MemFree(varIdArray);
00824   Cal_TempAssociationQuit(bddManager);
00825   Cal_BddManagerGC(bddManager);
00826 }

static void CalPerformanceTestSwapVars ( Cal_BddManager  bddManager,
Cal_Bdd *  outputBddArray,
int  numFunctions 
) [static]

Function********************************************************************

Synopsis [Performance test routine for quantify (all variables at the same time).]

Description [optional]

SideEffects [required]

SeeAlso [optional]

Definition at line 841 of file calPerformanceTest.c.

00843 {
00844   int i;
00845   int numVars = Cal_BddVars(bddManager);
00846   Cal_Bdd function, result;
00847   Cal_Bdd var1, var2;
00848   
00849   elapsedTime();
00850   cpuTime();
00851   pageFaults();
00852   for (i=0; i<ITERATION; i++){
00853     function = outputBddArray[CalUtilRandom()%numFunctions];
00854     var1 = Cal_BddManagerGetVarWithId(bddManager,(Cal_BddId_t)(CalUtilRandom()%numVars)+1);
00855     var2 = Cal_BddManagerGetVarWithId(bddManager,(Cal_BddId_t)(CalUtilRandom()%numVars)+1);
00856     result = Cal_BddSwapVars(bddManager, function, var1,var2);
00857     Cal_BddFree(bddManager, result);
00858   }
00859   fprintf(stdout, "%-20s%-10ld%-8.2f%-10ld\n", "SWAPVARS", elapsedTime(),
00860           cpuTime(), pageFaults());
00861   Cal_BddManagerGC(bddManager);
00862 }

static void CalQuantifySanityCheck ( Cal_BddManager  bddManager,
Cal_Bdd *  outputBddArray,
int  numFunctions 
) [static]

Function********************************************************************

Synopsis [Performance test routine for quantify (all variables at the same time).]

Description [optional]

SideEffects [required]

SeeAlso [optional]

Definition at line 669 of file calPerformanceTest.c.

00671 {
00672   int i, j;
00673   int numVars = Cal_BddVars(bddManager);
00674   int numQuantifyVars = numVars/2;
00675   int *varIdArray = Cal_MemAlloc(int, numQuantifyVars);
00676   Cal_Bdd *assoc = Cal_MemAlloc(Cal_Bdd, numQuantifyVars+1);
00677   Cal_Bdd function, oneAtATimeResult, allTogetherResult, tempResult, nonSuperscalarResult;
00678   
00679   
00680   for (i=0; i <= numQuantifyVars; i++){
00681     assoc[i] = (Cal_Bdd) 0;
00682   }
00683   
00684   (void) elapsedTime();
00685   for (i=0; i<ITERATION; i++){
00686     function = outputBddArray[CalUtilRandom()%numFunctions];
00687     GetRandomNumbers(1, numVars, numQuantifyVars, varIdArray);
00688     for (j=0; j<numQuantifyVars; j++){
00689       assoc[j] = Cal_BddManagerGetVarWithId(bddManager, varIdArray[j]);
00690     }
00691     Cal_TempAssociationInit(bddManager, assoc, 0);
00692     Cal_AssociationSetCurrent(bddManager, -1);
00693     allTogetherResult = Cal_BddExists(bddManager, function);
00694 
00695     oneAtATimeResult = Cal_BddIdentity(bddManager, function);
00696     qsort((void *) varIdArray, (size_t)numQuantifyVars, (size_t)sizeof(int),
00697           CalDecreasingOrderCompare);
00698     for (j=0; j<numQuantifyVars; j++){
00699       assoc[0] =
00700           Cal_BddManagerGetVarWithId(bddManager,varIdArray[j]); 
00701       assoc[1] = (Cal_Bdd) 0;
00702       Cal_TempAssociationAugment(bddManager, assoc, 0);
00703       tempResult = Cal_BddExists(bddManager, oneAtATimeResult);
00704       Cal_BddFree(bddManager, oneAtATimeResult);
00705       oneAtATimeResult = tempResult;
00706     }
00707     
00708     nonSuperscalarResult = Cal_BddExists(bddManager, function);
00709     
00710     assert(Cal_BddIsEqual(bddManager, allTogetherResult, oneAtATimeResult));
00711     assert(Cal_BddIsEqual(bddManager, allTogetherResult, nonSuperscalarResult));
00712     Cal_BddFree(bddManager, oneAtATimeResult); 
00713     Cal_BddFree(bddManager, allTogetherResult); 
00714     Cal_BddFree(bddManager, nonSuperscalarResult);
00715   }
00716   fprintf(stdout, "Quantify Sanity Check Passed\n");
00717   Cal_MemFree(assoc);
00718   Cal_MemFree(varIdArray);
00719   Cal_TempAssociationQuit(bddManager);
00720 }

static double cpuTime ( void   )  [static]

Function********************************************************************

Synopsis [Computes the number of page faults.]

Description [optional]

SideEffects [required]

SeeAlso [optional]

Definition at line 905 of file calPerformanceTest.c.

00906 {
00907 #if HAVE_SYS_RESOURCE_H
00908   static double timeNew, timeOld;
00909   struct rusage rusage;
00910   static int flag = 0;
00911   
00912   getrusage(RUSAGE_SELF, &rusage);
00913   if (flag == 0){
00914     timeOld = timeNew = rusage.ru_utime.tv_sec+
00915         ((double)rusage.ru_utime.tv_usec)/1000000;
00916     flag = 1;
00917   }
00918   else {
00919     timeOld = timeNew;
00920     timeNew = rusage.ru_utime.tv_sec+
00921         ((float)rusage.ru_utime.tv_usec)/1000000;
00922   }
00923   return timeNew - timeOld;
00924 #else /* No sys/resource.h */
00925   return 0;
00926 #endif
00927 }

static long elapsedTime ( void   )  [static]

Function********************************************************************

Synopsis [Computes the time.]

Description [optional]

SideEffects [required]

SeeAlso [optional]

Definition at line 875 of file calPerformanceTest.c.

00876 {
00877   static long time_new, time_old;
00878   struct timeval t;
00879   static int flag = 0;
00880   
00881   gettimeofday(&t, NULL);
00882   if (flag == 0){
00883     time_old = time_new = t.tv_sec;
00884     flag = 1;
00885   }
00886   else {
00887     time_old = time_new;
00888     time_new =  t.tv_sec;
00889   }
00890   return time_new-time_old;
00891 }

static void GetRandomNumbers ( int  lowerBound,
int  upperBound,
int  count,
int *  resultVector 
) [static]

Function********************************************************************

Synopsis [Generates "count" many random numbers ranging between "lowerBound" and "upperBound".]

Description [The restriction is that count <= upperBound-lowerBound+1. The size of the resultVector should be >= count.]

SideEffects [required]

SeeAlso [optional]

Definition at line 977 of file calPerformanceTest.c.

00978 {
00979   int i,j, tempVector[2048], number;
00980   int range = (upperBound - lowerBound + 1);
00981 
00982   for (i=0; i<range; i++)  tempVector[i] = lowerBound+i;
00983   for (i=0; i<count; i++){
00984     number = (int)CalUtilRandom()% (range-i);
00985     resultVector[i] = tempVector[number];
00986     for (j=number; j < range-i; j++){
00987       tempVector[j] = tempVector[j+1];
00988     }
00989   }
00990   /*
00991   fprintf(stdout,"%d\t%d\t%d\n", lowerBound, upperBound, count);
00992   for (i=0; i<count; i++)  fprintf(stdout,"%d ", resultVector[i]);
00993   fprintf(stdout, "\n");
00994   */
00995 }

static long pageFaults ( void   )  [static]

Function********************************************************************

Synopsis [Computes the number of page faults.]

Description [optional]

SideEffects [required]

SeeAlso [optional]

Definition at line 941 of file calPerformanceTest.c.

00942 {
00943 #if HAVE_SYS_RESOURCE_H
00944   static long faultNew, faultOld;
00945   struct rusage rusage;
00946   static int flag = 0;
00947   
00948   getrusage(RUSAGE_SELF, &rusage);
00949   if (flag == 0){
00950     faultOld = faultNew = rusage.ru_majflt;
00951     flag = 1;
00952   }
00953   else {
00954     faultOld = faultNew;
00955     faultNew = rusage.ru_majflt;
00956   }
00957   return faultNew - faultOld;
00958 #else /* Don't have sys/resource.h */
00959   return 0;
00960 #endif
00961 }

Variable Documentation

int ITERATION [static]

CFile***********************************************************************

FileName [calPerformanceTest.c]

PackageName [cal]

Synopsis [This file contains the performance test routines for the CAL package.]

Description [optional]

SeeAlso [optional]

Author [Rajeev K. Ranjan (rajeev@eecs.berkeley.edu) Jagesh Sanghavi (sanghavi@eecs.berkeley.edu) ]

Copyright [Copyright (c) 1994-1996 The Regents of the Univ. of California. All rights reserved.

Permission is hereby granted, without written agreement and without license or royalty fees, to use, copy, modify, and distribute this software and its documentation for any purpose, provided that the above copyright notice and the following two paragraphs appear in all copies of this software.

IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.]

Revision [

Id
calPerformanceTest.c,v 1.10 2005/04/30 22:57:39 fabio Exp

]

Definition at line 62 of file calPerformanceTest.c.

Generated on Tue Jan 12 13:57:12 2010 for glu-2.2 by  doxygen 1.6.1