/**Function*************************************************************
Synopsis [Resizes the table.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Map_SuperTableResize( Map_HashTable_t * p )
{
Map_HashEntry_t ** pBinsNew;
Map_HashEntry_t * pEnt, * pEnt2;
int nBinsNew, Counter, i, clk = clock();
unsigned Key;
// get the new table size
nBinsNew = Cudd_Prime(2 * p->nBins);
// allocate a new array
pBinsNew = ALLOC( Map_HashEntry_t *, nBinsNew );
memset( pBinsNew, 0, sizeof(Map_HashEntry_t *) * nBinsNew );
// rehash the entries from the old table
Counter = 0;
for ( i = 0; i < p->nBins; i++ )
for ( pEnt = p->pBins[i], pEnt2 = pEnt? pEnt->pNext: NULL; pEnt;
pEnt = pEnt2, pEnt2 = pEnt? pEnt->pNext: NULL )
{
Key = MAP_TABLE_HASH( pEnt->uTruth[0], pEnt->uTruth[1], nBinsNew );
pEnt->pNext = pBinsNew[Key];
pBinsNew[Key] = pEnt;
Counter++;
}
assert( Counter == p->nEntries );
// replace the table and the parameters
free( p->pBins );
p->pBins = pBinsNew;
p->nBins = nBinsNew;
}
/**Function*************************************************************
Synopsis [Resizes the table.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Map_TableResize( Map_Man_t * pMan )
{
Map_Node_t ** pBinsNew;
Map_Node_t * pEnt, * pEnt2;
int nBinsNew, Counter, i, clk;
unsigned Key;
clk = clock();
// get the new table size
nBinsNew = Cudd_Prime(2 * pMan->nBins);
// allocate a new array
pBinsNew = ALLOC( Map_Node_t *, nBinsNew );
memset( pBinsNew, 0, sizeof(Map_Node_t *) * nBinsNew );
// rehash the entries from the old table
Counter = 0;
for ( i = 0; i < pMan->nBins; i++ )
for ( pEnt = pMan->pBins[i], pEnt2 = pEnt? pEnt->pNext: NULL; pEnt;
pEnt = pEnt2, pEnt2 = pEnt? pEnt->pNext: NULL )
{
Key = Map_HashKey2( pEnt->p1, pEnt->p2, nBinsNew );
pEnt->pNext = pBinsNew[Key];
pBinsNew[Key] = pEnt;
Counter++;
}
assert( Counter == pMan->nNodes - pMan->nInputs );
if ( pMan->fVerbose )
{
// printf( "Increasing the unique table size from %6d to %6d. ", pMan->nBins, nBinsNew );
// PRT( "Time", clock() - clk );
}
// replace the table and the parameters
free( pMan->pBins );
pMan->pBins = pBinsNew;
pMan->nBins = nBinsNew;
}
/**Function*************************************************************
Synopsis [Create the unique table of AND gates.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Map_TableCreate( Map_Man_t * pMan )
{
assert( pMan->pBins == NULL );
pMan->nBins = Cudd_Prime(5000);
pMan->pBins = ALLOC( Map_Node_t *, pMan->nBins );
memset( pMan->pBins, 0, sizeof(Map_Node_t *) * pMan->nBins );
pMan->nNodes = 0;
}
/**Function*************************************************************
Synopsis [Creates the hash table for supergates.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Map_HashTable_t * Map_SuperTableCreate( Map_SuperLib_t * pLib )
{
Map_HashTable_t * p;
// allocate the table
p = ALLOC( Map_HashTable_t, 1 );
memset( p, 0, sizeof(Map_HashTable_t) );
p->mmMan = pLib->mmEntries;
// allocate and clean the bins
p->nBins = Cudd_Prime(20000);
p->pBins = ALLOC( Map_HashEntry_t *, p->nBins );
memset( p->pBins, 0, sizeof(Map_HashEntry_t *) * p->nBins );
return p;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Fxu_Matrix * Fxu_MatrixAllocate()
{
Fxu_Matrix * p;
p = ALLOC( Fxu_Matrix, 1 );
memset( p, 0, sizeof(Fxu_Matrix) );
p->nTableSize = Cudd_Prime(10000);
p->pTable = ALLOC( Fxu_ListDouble, p->nTableSize );
memset( p->pTable, 0, sizeof(Fxu_ListDouble) * p->nTableSize );
#ifndef USE_SYSTEM_MEMORY_MANAGEMENT
{
// get the largest size in bytes for the following structures:
// Fxu_Cube, Fxu_Var, Fxu_Lit, Fxu_Pair, Fxu_Double, Fxu_Single
// (currently, Fxu_Var, Fxu_Pair, Fxu_Double take 10 machine words)
int nSizeMax, nSizeCur;
nSizeMax = -1;
nSizeCur = sizeof(Fxu_Cube);
if ( nSizeMax < nSizeCur )
nSizeMax = nSizeCur;
nSizeCur = sizeof(Fxu_Var);
if ( nSizeMax < nSizeCur )
nSizeMax = nSizeCur;
nSizeCur = sizeof(Fxu_Lit);
if ( nSizeMax < nSizeCur )
nSizeMax = nSizeCur;
nSizeCur = sizeof(Fxu_Pair);
if ( nSizeMax < nSizeCur )
nSizeMax = nSizeCur;
nSizeCur = sizeof(Fxu_Double);
if ( nSizeMax < nSizeCur )
nSizeMax = nSizeCur;
nSizeCur = sizeof(Fxu_Single);
if ( nSizeMax < nSizeCur )
nSizeMax = nSizeCur;
p->pMemMan = Extra_MmFixedStart( nSizeMax );
}
#endif
p->pHeapDouble = Fxu_HeapDoubleStart();
p->pHeapSingle = Fxu_HeapSingleStart();
p->vPairs = Vec_PtrAlloc( 100 );
return p;
}
