summaryrefslogtreecommitdiffstats
path: root/abc70930/src/bdd/reo/reoTest.c
diff options
context:
space:
mode:
Diffstat (limited to 'abc70930/src/bdd/reo/reoTest.c')
-rw-r--r--abc70930/src/bdd/reo/reoTest.c251
1 files changed, 0 insertions, 251 deletions
diff --git a/abc70930/src/bdd/reo/reoTest.c b/abc70930/src/bdd/reo/reoTest.c
deleted file mode 100644
index 82f3d5f5..00000000
--- a/abc70930/src/bdd/reo/reoTest.c
+++ /dev/null
@@ -1,251 +0,0 @@
-/**CFile****************************************************************
-
- FileName [reoTest.c]
-
- PackageName [REO: A specialized DD reordering engine.]
-
- Synopsis [Various testing procedures (may be outdated).]
-
- Author [Alan Mishchenko <alanmi@ece.pdx.edu>]
-
- Affiliation [ECE Department. Portland State University, Portland, Oregon.]
-
- Date [Ver. 1.0. Started - October 15, 2002.]
-
- Revision [$Id: reoTest.c,v 1.0 2002/15/10 03:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "reo.h"
-
-////////////////////////////////////////////////////////////////////////
-/// DECLARATIONS ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-/// FUNCTION DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
- Synopsis [Reorders the DD using REO and CUDD.]
-
- Description [This function can be used to test the performance of the reordering package.]
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Extra_ReorderTest( DdManager * dd, DdNode * Func )
-{
- reo_man * pReo;
- DdNode * Temp, * Temp1;
- int pOrder[1000];
-
- pReo = Extra_ReorderInit( 100, 100 );
-
-//Extra_DumpDot( dd, &Func, 1, "beforReo.dot", 0 );
- Temp = Extra_Reorder( pReo, dd, Func, pOrder ); Cudd_Ref( Temp );
-//Extra_DumpDot( dd, &Temp, 1, "afterReo.dot", 0 );
-
- Temp1 = Extra_ReorderCudd(dd, Func, NULL ); Cudd_Ref( Temp1 );
-printf( "Initial = %d. Final = %d. Cudd = %d.\n", Cudd_DagSize(Func), Cudd_DagSize(Temp), Cudd_DagSize(Temp1) );
- Cudd_RecursiveDeref( dd, Temp1 );
- Cudd_RecursiveDeref( dd, Temp );
-
- Extra_ReorderQuit( pReo );
-}
-
-
-/**Function*************************************************************
-
- Synopsis [Reorders the DD using REO and CUDD.]
-
- Description [This function can be used to test the performance of the reordering package.]
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Extra_ReorderTestArray( DdManager * dd, DdNode * Funcs[], int nFuncs )
-{
- reo_man * pReo;
- DdNode * FuncsRes[1000];
- int pOrder[1000];
- int i;
-
- pReo = Extra_ReorderInit( 100, 100 );
- Extra_ReorderArray( pReo, dd, Funcs, FuncsRes, nFuncs, pOrder );
- Extra_ReorderQuit( pReo );
-
-printf( "Initial = %d. Final = %d.\n", Cudd_SharingSize(Funcs,nFuncs), Cudd_SharingSize(FuncsRes,nFuncs) );
-
- for ( i = 0; i < nFuncs; i++ )
- Cudd_RecursiveDeref( dd, FuncsRes[i] );
-
-}
-
-/**Function*************************************************************
-
- Synopsis [Reorders the DD using CUDD package.]
-
- Description [Transfers the DD into a temporary manager in such a way
- that the level correspondence is preserved. Reorders the manager
- and transfers the DD back into the original manager using the topmost
- levels of the manager, in such a way that the ordering of levels is
- preserved. The resulting permutation is returned in the array
- given by the user.]
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-DdNode * Extra_ReorderCudd( DdManager * dd, DdNode * aFunc, int pPermuteReo[] )
-{
- static DdManager * ddReorder = NULL;
- static int * Permute = NULL;
- static int * PermuteReo1 = NULL;
- static int * PermuteReo2 = NULL;
- DdNode * aFuncReorder, * aFuncNew;
- int lev, var;
-
- // start the reordering manager
- if ( ddReorder == NULL )
- {
- Permute = ALLOC( int, dd->size );
- PermuteReo1 = ALLOC( int, dd->size );
- PermuteReo2 = ALLOC( int, dd->size );
- ddReorder = Cudd_Init( dd->size, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
- Cudd_AutodynDisable(ddReorder);
- }
-
- // determine the permutation of variable to make sure that var order in bFunc
- // will not change when this function is transfered into the new manager
- for ( lev = 0; lev < dd->size; lev++ )
- {
- Permute[ dd->invperm[lev] ] = ddReorder->invperm[lev];
- PermuteReo1[ ddReorder->invperm[lev] ] = dd->invperm[lev];
- }
- // transfer this function into the new manager in such a way that ordering of vars does not change
- aFuncReorder = Extra_TransferPermute( dd, ddReorder, aFunc, Permute ); Cudd_Ref( aFuncReorder );
-// assert( Cudd_DagSize(aFunc) == Cudd_DagSize(aFuncReorder) );
-
- // perform the reordering
-printf( "Nodes before = %d.\n", Cudd_DagSize(aFuncReorder) );
- Cudd_ReduceHeap( ddReorder, CUDD_REORDER_SYMM_SIFT, 1 );
-printf( "Nodes before = %d.\n", Cudd_DagSize(aFuncReorder) );
-
- // determine the reverse variable permutation
- for ( lev = 0; lev < dd->size; lev++ )
- {
- Permute[ ddReorder->invperm[lev] ] = dd->invperm[lev];
- PermuteReo2[ dd->invperm[lev] ] = ddReorder->invperm[lev];
- }
-
- // transfer this function into the new manager in such a way that ordering of vars does not change
- aFuncNew = Extra_TransferPermute( ddReorder, dd, aFuncReorder, Permute ); Cudd_Ref( aFuncNew );
-// assert( Cudd_DagSize(aFuncNew) == Cudd_DagSize(aFuncReorder) );
- Cudd_RecursiveDeref( ddReorder, aFuncReorder );
-
- // derive the resulting variable ordering
- if ( pPermuteReo )
- for ( var = 0; var < dd->size; var++ )
- pPermuteReo[var] = PermuteReo1[ PermuteReo2[var] ];
-
- Cudd_Deref( aFuncNew );
- return aFuncNew;
-}
-
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description [Transfers the BDD into another manager minimizes it and
- returns the min number of nodes; disposes of the BDD in the new manager.
- Useful for debugging or comparing the performance of other reordering
- procedures.]
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-int Extra_bddReorderTest( DdManager * dd, DdNode * bF )
-{
- static DdManager * s_ddmin;
- DdNode * bFmin;
- int nNodes;
-// int clk1;
-
- if ( s_ddmin == NULL )
- s_ddmin = Cudd_Init( dd->size, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0);
-
-// Cudd_ShuffleHeap( s_ddmin, dd->invperm );
-
-// clk1 = clock();
- bFmin = Cudd_bddTransfer( dd, s_ddmin, bF ); Cudd_Ref( bFmin );
- Cudd_ReduceHeap(s_ddmin,CUDD_REORDER_SIFT,1);
-// Cudd_ReduceHeap(s_ddmin,CUDD_REORDER_SYMM_SIFT,1);
- nNodes = Cudd_DagSize( bFmin );
- Cudd_RecursiveDeref( s_ddmin, bFmin );
-
-// printf( "Classical variable reordering time = %.2f sec\n", (float)(clock() - clk1)/(float)(CLOCKS_PER_SEC) );
- return nNodes;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description [Transfers the ADD into another manager minimizes it and
- returns the min number of nodes; disposes of the BDD in the new manager.
- Useful for debugging or comparing the performance of other reordering
- procedures.]
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-int Extra_addReorderTest( DdManager * dd, DdNode * aF )
-{
- static DdManager * s_ddmin;
- DdNode * bF;
- DdNode * bFmin;
- DdNode * aFmin;
- int nNodesBeg;
- int nNodesEnd;
- int clk1;
-
- if ( s_ddmin == NULL )
- s_ddmin = Cudd_Init( dd->size, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0);
-
-// Cudd_ShuffleHeap( s_ddmin, dd->invperm );
-
- clk1 = clock();
- bF = Cudd_addBddPattern( dd, aF ); Cudd_Ref( bF );
- bFmin = Cudd_bddTransfer( dd, s_ddmin, bF ); Cudd_Ref( bFmin );
- Cudd_RecursiveDeref( dd, bF );
- aFmin = Cudd_BddToAdd( s_ddmin, bFmin ); Cudd_Ref( aFmin );
- Cudd_RecursiveDeref( s_ddmin, bFmin );
-
- nNodesBeg = Cudd_DagSize( aFmin );
- Cudd_ReduceHeap(s_ddmin,CUDD_REORDER_SIFT,1);
-// Cudd_ReduceHeap(s_ddmin,CUDD_REORDER_SYMM_SIFT,1);
- nNodesEnd = Cudd_DagSize( aFmin );
- Cudd_RecursiveDeref( s_ddmin, aFmin );
-
- printf( "Classical reordering of ADDs: Before = %d. After = %d.\n", nNodesBeg, nNodesEnd );
- printf( "Classical variable reordering time = %.2f sec\n", (float)(clock() - clk1)/(float)(CLOCKS_PER_SEC) );
- return nNodesEnd;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-/// END OF FILE ///
-////////////////////////////////////////////////////////////////////////
-
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-20 19:35:42 +0000