ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Creates a graph with the given number of leaves.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Kit_Graph_t * Kit_GraphCreate( int nLeaves )
{
Kit_Graph_t * pGraph;
pGraph = ABC_ALLOC( Kit_Graph_t, 1 );
memset( pGraph, 0, sizeof(Kit_Graph_t) );
pGraph->nLeaves = nLeaves;
pGraph->nSize = nLeaves;
pGraph->nCap = 2 * nLeaves + 50;
pGraph->pNodes = ABC_ALLOC( Kit_Node_t, pGraph->nCap );
memset( pGraph->pNodes, 0, sizeof(Kit_Node_t) * pGraph->nSize );
return pGraph;
}
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Cov_Man_t * Cov_ManAlloc( Abc_Ntk_t * pNtk, int nFaninMax )
{
Cov_Man_t * pMan;
Cov_Obj_t * pMem;
Abc_Obj_t * pObj;
int i;
assert( pNtk->pManCut == NULL );
// start the manager
pMan = ABC_ALLOC( Cov_Man_t, 1 );
memset( pMan, 0, sizeof(Cov_Man_t) );
pMan->nFaninMax = nFaninMax;
pMan->nCubesMax = 2 * pMan->nFaninMax;
pMan->nWords = Abc_BitWordNum( nFaninMax * 2 );
// get the cubes
pMan->vComTo0 = Vec_IntAlloc( 2*nFaninMax );
pMan->vComTo1 = Vec_IntAlloc( 2*nFaninMax );
pMan->vPairs0 = Vec_IntAlloc( nFaninMax );
pMan->vPairs1 = Vec_IntAlloc( nFaninMax );
pMan->vTriv0 = Vec_IntAlloc( 1 ); Vec_IntPush( pMan->vTriv0, -1 );
pMan->vTriv1 = Vec_IntAlloc( 1 ); Vec_IntPush( pMan->vTriv1, -1 );
// allocate memory for object structures
pMan->pMemory = pMem = ABC_ALLOC( Cov_Obj_t, sizeof(Cov_Obj_t) * Abc_NtkObjNumMax(pNtk) );
memset( pMem, 0, sizeof(Cov_Obj_t) * Abc_NtkObjNumMax(pNtk) );
// allocate storage for the pointers to the memory
pMan->vObjStrs = Vec_PtrAlloc( Abc_NtkObjNumMax(pNtk) );
Vec_PtrFill( pMan->vObjStrs, Abc_NtkObjNumMax(pNtk), NULL );
Abc_NtkForEachObj( pNtk, pObj, i )
Vec_PtrWriteEntry( pMan->vObjStrs, i, pMem + i );
// create the cube manager
pMan->pManMin = Min_ManAlloc( nFaninMax );
return pMan;
}
/**Function*************************************************************
Synopsis [Starts the library.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Super2_Lib_t * Super2_LibStart()
{
Super2_Lib_t * pLib;
pLib = ABC_ALLOC( Super2_Lib_t, 1 );
memset( pLib, 0, sizeof(Super2_Lib_t) );
return pLib;
}
/**Function*************************************************************
Synopsis [Starts the monolithic image computation.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Extra_ImageTree2_t * Extra_bddImageStart2(
DdManager * dd, DdNode * bCare,
int nParts, DdNode ** pbParts,
int nVars, DdNode ** pbVars, int fVerbose )
{
Extra_ImageTree2_t * pTree;
DdNode * bCubeAll, * bCubeNot, * bTemp;
int i;
pTree = ABC_ALLOC( Extra_ImageTree2_t, 1 );
pTree->dd = dd;
pTree->bImage = NULL;
bCubeAll = Extra_bddComputeCube( dd, dd->vars, dd->size ); Cudd_Ref( bCubeAll );
bCubeNot = Extra_bddComputeCube( dd, pbVars, nVars ); Cudd_Ref( bCubeNot );
pTree->bCube = Cudd_bddExistAbstract( dd, bCubeAll, bCubeNot ); Cudd_Ref( pTree->bCube );
Cudd_RecursiveDeref( dd, bCubeAll );
Cudd_RecursiveDeref( dd, bCubeNot );
// derive the monolithic relation
pTree->bRel = b1; Cudd_Ref( pTree->bRel );
for ( i = 0; i < nParts; i++ )
{
pTree->bRel = Cudd_bddAnd( dd, bTemp = pTree->bRel, pbParts[i] ); Cudd_Ref( pTree->bRel );
Cudd_RecursiveDeref( dd, bTemp );
}
Extra_bddImageCompute2( pTree, bCare );
return pTree;
}
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Allocs a library.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Amap_Lib_t * Amap_LibAlloc()
{
Amap_Lib_t * p;
p = (Amap_Lib_t *)ABC_ALLOC( Amap_Lib_t, 1 );
memset( p, 0, sizeof(Amap_Lib_t) );
p->vGates = Vec_PtrAlloc( 100 );
p->pMemGates = Aig_MmFlexStart();
p->pMemSet = Aig_MmFlexStart();
return p;
}
int
st_find_or_add(st_table *table, char *key, char ***slot)
{
int hash_val;
st_table_entry *newEntry, *ptr, **last;
hash_val = do_hash(key, table);
FIND_ENTRY(table, hash_val, key, ptr, last);
if (ptr == NULL) {
if (table->num_entries / table->num_bins >= table->max_density) {
if (rehash(table) == ST_OUT_OF_MEM) {
return ST_OUT_OF_MEM;
}
hash_val = do_hash(key, table);
}
newEntry = ABC_ALLOC(st_table_entry, 1);
if (newEntry == NULL) {
return ST_OUT_OF_MEM;
}
newEntry->key = key;
newEntry->record = (char *) 0;
newEntry->next = table->bins[hash_val];
table->bins[hash_val] = newEntry;
table->num_entries++;
if (slot != NULL) *slot = &newEntry->record;
return 0;
} else {
if (slot != NULL) *slot = &ptr->record;
return 1;
}
}
/**Function*************************************************************
Synopsis [Starts the simulation manager.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Sim_Man_t * Sim_ManStart( Abc_Ntk_t * pNtk, int fLightweight )
{
Sim_Man_t * p;
// start the manager
p = ABC_ALLOC( Sim_Man_t, 1 );
memset( p, 0, sizeof(Sim_Man_t) );
p->pNtk = pNtk;
p->nInputs = Abc_NtkCiNum(p->pNtk);
p->nOutputs = Abc_NtkCoNum(p->pNtk);
// internal simulation information
p->nSimBits = 2048;
p->nSimWords = SIM_NUM_WORDS(p->nSimBits);
p->vSim0 = Sim_UtilInfoAlloc( Abc_NtkObjNumMax(pNtk), p->nSimWords, 0 );
p->fLightweight = fLightweight;
if (!p->fLightweight) {
p->vSim1 = Sim_UtilInfoAlloc( Abc_NtkObjNumMax(pNtk), p->nSimWords, 0 );
// support information
p->nSuppBits = Abc_NtkCiNum(pNtk);
p->nSuppWords = SIM_NUM_WORDS(p->nSuppBits);
p->vSuppStr = Sim_ComputeStrSupp( pNtk );
p->vSuppFun = Sim_UtilInfoAlloc( Abc_NtkCoNum(p->pNtk), p->nSuppWords, 1 );
// other data
p->pMmPat = Extra_MmFixedStart( sizeof(Sim_Pat_t) + p->nSuppWords * sizeof(unsigned) );
p->vFifo = Vec_PtrAlloc( 100 );
p->vDiffs = Vec_IntAlloc( 100 );
// allocate support targets (array of unresolved outputs for each input)
p->vSuppTargs = Vec_VecStart( p->nInputs );
}
return p;
}
st_table *
st_init_table_with_params(st_compare_func_type compare, st_hash_func_type hash, int size, int density, double grow_factor, int reorder_flag)
{
int i;
st_table *newTable;
newTable = ABC_ALLOC(st_table, 1);
if (newTable == NULL) {
return NULL;
}
newTable->compare = compare;
newTable->hash = hash;
newTable->num_entries = 0;
newTable->max_density = density;
newTable->grow_factor = grow_factor;
newTable->reorder_flag = reorder_flag;
if (size <= 0) {
size = 1;
}
newTable->num_bins = size;
newTable->bins = ABC_ALLOC(st_table_entry *, size);
if (newTable->bins == NULL) {
ABC_FREE(newTable);
return NULL;
}
for(i = 0; i < size; i++) {
newTable->bins[i] = 0;
}
return newTable;
}
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Creates the interpolation manager.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Inter_Man_t * Inter_ManCreate( Aig_Man_t * pAig, Inter_ManParams_t * pPars )
{
Inter_Man_t * p;
// create interpolation manager
p = ABC_ALLOC( Inter_Man_t, 1 );
memset( p, 0, sizeof(Inter_Man_t) );
p->vVarsAB = Vec_IntAlloc( Aig_ManRegNum(pAig) );
p->nConfLimit = pPars->nBTLimit;
p->fVerbose = pPars->fVerbose;
p->pAig = pAig;
return p;
}
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Mvc_Manager_t * Mvc_ManagerStart()
{
Mvc_Manager_t * p;
p = ABC_ALLOC( Mvc_Manager_t, 1 );
memset( p, 0, sizeof(Mvc_Manager_t) );
p->pMan1 = Extra_MmFixedStart( sizeof(Mvc_Cube_t) );
p->pMan2 = Extra_MmFixedStart( sizeof(Mvc_Cube_t) + sizeof(Mvc_CubeWord_t) );
p->pMan4 = Extra_MmFixedStart( sizeof(Mvc_Cube_t) + 3 * sizeof(Mvc_CubeWord_t) );
p->pManC = Extra_MmFixedStart( sizeof(Mvc_Cover_t) );
return p;
}
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Allocates a vector with the given capacity.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Fraig_NodeVec_t * Fraig_NodeVecAlloc( int nCap )
{
Fraig_NodeVec_t * p;
p = ABC_ALLOC( Fraig_NodeVec_t, 1 );
if ( nCap > 0 && nCap < 8 )
nCap = 8;
p->nSize = 0;
p->nCap = nCap;
p->pArray = p->nCap? ABC_ALLOC( Fraig_Node_t *, p->nCap ) : NULL;
return p;
}
int
st_insert(st_table *table, const char *key, char *value)
{
int hash_val;
st_table_entry *newEntry;
st_table_entry *ptr, **last;
hash_val = do_hash(key, table);
FIND_ENTRY(table, hash_val, key, ptr, last);
if (ptr == NULL) {
if (table->num_entries/table->num_bins >= table->max_density) {
if (rehash(table) == ST_OUT_OF_MEM) {
return ST_OUT_OF_MEM;
}
hash_val = do_hash(key, table);
}
newEntry = ABC_ALLOC(st_table_entry, 1);
if (newEntry == NULL) {
return ST_OUT_OF_MEM;
}
newEntry->key = (char *)key;
newEntry->record = value;
newEntry->next = table->bins[hash_val];
table->bins[hash_val] = newEntry;
table->num_entries++;
return 0;
} else {
ptr->record = value;
return 1;
}
}
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Prepares the mapping manager.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Lpk_IfManStart( Lpk_Man_t * p )
{
If_Par_t * pPars;
assert( p->pIfMan == NULL );
// set defaults
pPars = ABC_ALLOC( If_Par_t, 1 );
memset( pPars, 0, sizeof(If_Par_t) );
// user-controlable paramters
pPars->nLutSize = p->pPars->nLutSize;
pPars->nCutsMax = 16;
pPars->nFlowIters = 0; // 1
pPars->nAreaIters = 0; // 1
pPars->DelayTarget = -1;
pPars->Epsilon = (float)0.005;
pPars->fPreprocess = 0;
pPars->fArea = 1;
pPars->fFancy = 0;
pPars->fExpRed = 0; //
pPars->fLatchPaths = 0;
pPars->fVerbose = 0;
// internal parameters
pPars->fTruth = 1;
pPars->fUsePerm = 0;
pPars->nLatchesCi = 0;
pPars->nLatchesCo = 0;
pPars->pLutLib = NULL; // Abc_FrameReadLibLut();
pPars->pTimesArr = NULL;
pPars->pTimesArr = NULL;
pPars->fUseBdds = 0;
pPars->fUseSops = 0;
pPars->fUseCnfs = 0;
pPars->fUseMv = 0;
// start the mapping manager and set its parameters
p->pIfMan = If_ManStart( pPars );
If_ManSetupSetAll( p->pIfMan, 1000 );
p->pIfMan->pPars->pTimesArr = ABC_ALLOC( float, 32 );
}
/**Function*************************************************************
Synopsis [Creates constant 1 graph.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Kit_Graph_t * Kit_GraphCreateConst1()
{
Kit_Graph_t * pGraph;
pGraph = ABC_ALLOC( Kit_Graph_t, 1 );
memset( pGraph, 0, sizeof(Kit_Graph_t) );
pGraph->fConst = 1;
return pGraph;
}
/**Function*************************************************************
Synopsis [Starts the manager.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Super2_Man_t * Super2_ManStart()
{
Super2_Man_t * pMan;
pMan = ABC_ALLOC( Super2_Man_t, 1 );
memset( pMan, 0, sizeof(Super2_Man_t) );
pMan->pMem = Extra_MmFixedStart( sizeof(Super2_Gate_t) );
pMan->tTable = stmm_init_table( st_ptrcmp, st_ptrhash );
return pMan;
}
st_table *
st_copy(st_table *old_table)
{
st_table *newEntry_table;
st_table_entry *ptr, *newEntryptr, *next, *newEntry;
int i, j, num_bins = old_table->num_bins;
newEntry_table = ABC_ALLOC(st_table, 1);
if (newEntry_table == NULL) {
return NULL;
}
*newEntry_table = *old_table;
newEntry_table->bins = ABC_ALLOC(st_table_entry *, num_bins);
if (newEntry_table->bins == NULL) {
ABC_FREE(newEntry_table);
return NULL;
}
for(i = 0; i < num_bins ; i++) {
newEntry_table->bins[i] = NULL;
ptr = old_table->bins[i];
while (ptr != NULL) {
newEntry = ABC_ALLOC(st_table_entry, 1);
if (newEntry == NULL) {
for (j = 0; j <= i; j++) {
newEntryptr = newEntry_table->bins[j];
while (newEntryptr != NULL) {
next = newEntryptr->next;
ABC_FREE(newEntryptr);
newEntryptr = next;
}
}
ABC_FREE(newEntry_table->bins);
ABC_FREE(newEntry_table);
return NULL;
}
*newEntry = *ptr;
newEntry->next = newEntry_table->bins[i];
newEntry_table->bins[i] = newEntry;
ptr = ptr->next;
}
}
return newEntry_table;
}
/**Function*************************************************************
Synopsis [Creates AIG.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Cec_ManFra_t * Cec_ManFraStart( Gia_Man_t * pAig, Cec_ParFra_t * pPars )
{
Cec_ManFra_t * p;
p = ABC_ALLOC( Cec_ManFra_t, 1 );
memset( p, 0, sizeof(Cec_ManFra_t) );
p->pAig = pAig;
p->pPars = pPars;
p->vXorNodes = Vec_IntAlloc( 1000 );
return p;
}
/**Function*************************************************************
Synopsis [Duplicates the integer array.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Fraig_NodeVec_t * Fraig_NodeVecDup( Fraig_NodeVec_t * pVec )
{
Fraig_NodeVec_t * p;
p = ABC_ALLOC( Fraig_NodeVec_t, 1 );
p->nSize = pVec->nSize;
p->nCap = pVec->nCap;
p->pArray = p->nCap? ABC_ALLOC( Fraig_Node_t *, p->nCap ) : NULL;
memcpy( p->pArray, pVec->pArray, sizeof(Fraig_Node_t *) * pVec->nSize );
return p;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Mio_Pin_t * Mio_PinDup( Mio_Pin_t * pPin )
{
Mio_Pin_t * pPinNew;
pPinNew = ABC_ALLOC( Mio_Pin_t, 1 );
*pPinNew = *pPin;
pPinNew->pName = (pPinNew->pName ? Abc_UtilStrsav(pPinNew->pName) : NULL);
pPinNew->pNext = NULL;
return pPinNew;
}
/**Function*************************************************************
Synopsis [Allocates a vector with the given capacity.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Map_NodeVec_t * Map_NodeVecAlloc( int nCap )
{
Map_NodeVec_t * p;
p = ABC_ALLOC( Map_NodeVec_t, 1 );
if ( nCap > 0 && nCap < 16 )
nCap = 16;
p->nSize = 0;
p->nCap = nCap;
p->pArray = p->nCap? ABC_ALLOC( Map_Node_t *, p->nCap ) : NULL;
return p;
}
/**Function*************************************************************
Synopsis [Start the memory manager.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Supp_Man_t * Supp_ManStart( int nChunkSize, int nStepSize )
{
Supp_Man_t * p;
p = ABC_ALLOC( Supp_Man_t, 1 );
memset( p, 0, sizeof(Supp_Man_t) );
p->nChunkSize = nChunkSize;
p->nStepSize = nStepSize;
p->vMemory = Vec_PtrAlloc( 1000 );
p->vFree = Vec_PtrAlloc( 1000 );
return p;
}
ABC_NAMESPACE_IMPL_START
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
/**Function*************************************************************
Synopsis [Starts the timing manager.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Tim_Man_t * Tim_ManStart( int nCis, int nCos )
{
Tim_Man_t * p;
Tim_Obj_t * pObj;
int i;
p = ABC_ALLOC( Tim_Man_t, 1 );
memset( p, 0, sizeof(Tim_Man_t) );
p->pMemObj = Mem_FlexStart();
p->nCis = nCis;
p->nCos = nCos;
p->pCis = ABC_ALLOC( Tim_Obj_t, nCis );
memset( p->pCis, 0, sizeof(Tim_Obj_t) * nCis );
p->pCos = ABC_ALLOC( Tim_Obj_t, nCos );
memset( p->pCos, 0, sizeof(Tim_Obj_t) * nCos );
Tim_ManForEachCi( p, pObj, i )
{
pObj->Id = i;
pObj->iObj2Box = pObj->iObj2Num = -1;
pObj->timeReq = TIM_ETERNITY;
}
/**Function*************************************************************
Synopsis [Merges two nodes.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Extra_ImageNode_t * Extra_CombineTwoNodes( DdManager * dd, DdNode * bCube,
Extra_ImageNode_t * pNode1, Extra_ImageNode_t * pNode2 )
{
Extra_ImageNode_t * pNode;
Extra_ImagePart_t * pPart;
// create a new partition
pPart = ABC_ALLOC( Extra_ImagePart_t, 1 );
memset( pPart, 0, sizeof(Extra_ImagePart_t) );
// create the function
pPart->bFunc = Cudd_bddAndAbstract( dd, pNode1->pPart->bFunc, pNode2->pPart->bFunc, bCube );
Cudd_Ref( pPart->bFunc );
// update the support the partition
pPart->bSupp = Cudd_bddAndAbstract( dd, pNode1->pPart->bSupp, pNode2->pPart->bSupp, bCube );
Cudd_Ref( pPart->bSupp );
// update the numbers
pPart->nSupp = Extra_bddSuppSize( dd, pPart->bSupp );
pPart->nNodes = Cudd_DagSize( pPart->bFunc );
pPart->iPart = -1;
/*
ABC_PRB( dd, pNode1->pPart->bSupp );
ABC_PRB( dd, pNode2->pPart->bSupp );
ABC_PRB( dd, pPart->bSupp );
*/
// create a new node
pNode = ABC_ALLOC( Extra_ImageNode_t, 1 );
memset( pNode, 0, sizeof(Extra_ImageNode_t) );
pNode->dd = dd;
pNode->pPart = pPart;
pNode->pNode1 = pNode1;
pNode->pNode2 = pNode2;
// compute the image
pNode->bImage = Cudd_bddAndAbstract( dd, pNode1->bImage, pNode2->bImage, bCube );
Cudd_Ref( pNode->bImage );
// save the cube
if ( bCube != b1 )
{
pNode->bCube = bCube; Cudd_Ref( bCube );
}
return pNode;
}
/**Function*************************************************************
Synopsis [Create the mapping manager.]
Description [The number of inputs and outputs is assumed to be
known is advance. It is much simpler to have them fixed upfront.
When it comes to representing the object graph in the form of
AIG, the resulting manager is similar to the regular AIG manager,
except that it does not use reference counting (and therefore
does not have garbage collections). It does have table resizing.
The data structure is more flexible to represent additional
information needed for mapping.]
SideEffects []
SeeAlso []
***********************************************************************/
Map_Man_t * Map_ManCreate( int nInputs, int nOutputs, int fVerbose )
{
Map_Man_t * p;
int i;
// derive the supergate library
if ( Abc_FrameReadLibSuper() == NULL )
{
printf( "The supergate library is not specified. Use \"read_super\".\n" );
return NULL;
}
// start the manager
p = ABC_ALLOC( Map_Man_t, 1 );
memset( p, 0, sizeof(Map_Man_t) );
p->pSuperLib = (Map_SuperLib_t *)Abc_FrameReadLibSuper();
p->nVarsMax = p->pSuperLib->nVarsMax;
p->fVerbose = fVerbose;
p->fEpsilon = (float)0.001;
assert( p->nVarsMax > 0 );
if ( p->nVarsMax == 5 )
Extra_Truth4VarN( &p->uCanons, &p->uPhases, &p->pCounters, 8 );
// start various data structures
Map_TableCreate( p );
Map_MappingSetupTruthTables( p->uTruths );
Map_MappingSetupTruthTablesLarge( p->uTruthsLarge );
// printf( "Node = %d bytes. Cut = %d bytes. Super = %d bytes.\n", sizeof(Map_Node_t), sizeof(Map_Cut_t), sizeof(Map_Super_t) );
p->mmNodes = Extra_MmFixedStart( sizeof(Map_Node_t) );
p->mmCuts = Extra_MmFixedStart( sizeof(Map_Cut_t) );
// make sure the constant node will get index -1
p->nNodes = -1;
// create the constant node
p->pConst1 = Map_NodeCreate( p, NULL, NULL );
p->vNodesAll = Map_NodeVecAlloc( 100 );
p->vNodesTemp = Map_NodeVecAlloc( 100 );
p->vMapping = Map_NodeVecAlloc( 100 );
p->vVisited = Map_NodeVecAlloc( 100 );
// create the PI nodes
p->nInputs = nInputs;
p->pInputs = ABC_ALLOC( Map_Node_t *, nInputs );
for ( i = 0; i < nInputs; i++ )
p->pInputs[i] = Map_NodeCreate( p, NULL, NULL );
// create the place for the output nodes
p->nOutputs = nOutputs;
p->pOutputs = ABC_ALLOC( Map_Node_t *, nOutputs );
memset( p->pOutputs, 0, sizeof(Map_Node_t *) * nOutputs );
return p;
}
/**Function*************************************************************
Synopsis [Allocates the target result.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
CSAT_Target_ResultT * ABC_TargetResAlloc( int nVars )
{
CSAT_Target_ResultT * p;
p = ABC_ALLOC( CSAT_Target_ResultT, 1 );
memset( p, 0, sizeof(CSAT_Target_ResultT) );
p->no_sig = nVars;
p->names = ABC_ALLOC( char *, nVars );
p->values = ABC_ALLOC( int, nVars );
memset( p->names, 0, sizeof(char *) * nVars );
memset( p->values, 0, sizeof(int) * nVars );
return p;
}
/**Function*************************************************************
Synopsis [Starts the image computation using tree-based scheduling.]
Description [This procedure starts the image computation. It uses
the given care set to test-run the image computation and creates the
quantification tree by scheduling variable quantifications. The tree can
be used to compute images for other care sets without rescheduling.
In this case, Extra_bddImageCompute() should be called.]
SideEffects []
SeeAlso []
***********************************************************************/
Extra_ImageTree_t * Extra_bddImageStart(
DdManager * dd, DdNode * bCare, // the care set
int nParts, DdNode ** pbParts, // the partitions for image computation
int nVars, DdNode ** pbVars, int fVerbose ) // the NS and parameter variables (not quantified!)
{
Extra_ImageTree_t * pTree;
Extra_ImagePart_t ** pParts;
Extra_ImageVar_t ** pVars;
Extra_ImageNode_t ** pNodes;
int v;
if ( fVerbose && dd->size <= 80 )
Extra_bddImagePrintLatchDependency( dd, bCare, nParts, pbParts, nVars, pbVars );
// create variables, partitions and leaf nodes
pParts = Extra_CreateParts( dd, nParts, pbParts, bCare );
pVars = Extra_CreateVars( dd, nParts + 1, pParts, nVars, pbVars );
pNodes = Extra_CreateNodes( dd, nParts + 1, pParts, dd->size, pVars );
// create the tree
pTree = ABC_ALLOC( Extra_ImageTree_t, 1 );
memset( pTree, 0, sizeof(Extra_ImageTree_t) );
pTree->pCare = pNodes[nParts];
pTree->fVerbose = fVerbose;
// process the nodes
while ( Extra_BuildTreeNode( dd, nParts + 1, pNodes, dd->size, pVars ) );
// make sure the variables are gone
for ( v = 0; v < dd->size; v++ )
assert( pVars[v] == NULL );
ABC_FREE( pVars );
// merge the topmost nodes
while ( (pTree->pRoot = Extra_MergeTopNodes( dd, nParts + 1, pNodes )) == NULL );
// make sure the nodes are gone
for ( v = 0; v < nParts + 1; v++ )
assert( pNodes[v] == NULL );
ABC_FREE( pNodes );
// if ( fVerbose )
// Extra_bddImagePrintTree( pTree );
// set the support of the care set
pTree->bCareSupp = Cudd_Support( dd, bCare ); Cudd_Ref( pTree->bCareSupp );
// clean the partitions
Extra_DeleteParts_rec( pTree->pRoot );
ABC_FREE( pParts );
return pTree;
}
/**Function********************************************************************
Synopsis [(Re)allocates the local cache.]
Description []
SideEffects []
SeeAlso []
******************************************************************************/
void Dsd_CheckCacheAllocate( int nEntries )
{
int nRequested;
pCache = ABC_ALLOC( Dds_Cache_t, 1 );
memset( pCache, 0, sizeof(Dds_Cache_t) );
// check what is the size of the current cache
nRequested = Abc_PrimeCudd( nEntries );
if ( pCache->nTableSize != nRequested )
{ // the current size is different
// deallocate the old, allocate the new
if ( pCache->nTableSize )
Dsd_CheckCacheDeallocate();
// allocate memory for the hash table
pCache->nTableSize = nRequested;
pCache->pTable = ABC_ALLOC( Dsd_Entry_t, nRequested );
}
// otherwise, there is no need to allocate, just clean
Dsd_CheckCacheClear();
// printf( "\nThe number of allocated cache entries = %d.\n\n", pCache->nTableSize );
}
/**Function*************************************************************
Synopsis [Starts representation of equivalence classes.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Dch_Cla_t * Dch_ClassesStart( Aig_Man_t * pAig )
{
Dch_Cla_t * p;
p = ABC_ALLOC( Dch_Cla_t, 1 );
memset( p, 0, sizeof(Dch_Cla_t) );
p->pAig = pAig;
p->pId2Class = ABC_CALLOC( Aig_Obj_t **, Aig_ManObjNumMax(pAig) );
p->pClassSizes = ABC_CALLOC( int, Aig_ManObjNumMax(pAig) );
p->vClassOld = Vec_PtrAlloc( 100 );
p->vClassNew = Vec_PtrAlloc( 100 );
assert( pAig->pReprs == NULL );
Aig_ManReprStart( pAig, Aig_ManObjNumMax(pAig) );
return p;
}
st_generator *
st_init_gen(st_table *table)
{
st_generator *gen;
gen = ABC_ALLOC(st_generator, 1);
if (gen == NULL) {
return NULL;
}
gen->table = table;
gen->entry = NULL;
gen->index = 0;
return gen;
}
/**Function*************************************************************
Synopsis [Starts the library.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Dar_Lib_t * Dar_LibAlloc( int nObjs )
{
unsigned uTruths[4] = { 0xAAAA, 0xCCCC, 0xF0F0, 0xFF00 };
Dar_Lib_t * p;
int i;//, clk = clock();
p = ABC_ALLOC( Dar_Lib_t, 1 );
memset( p, 0, sizeof(Dar_Lib_t) );
// allocate objects
p->nObjs = nObjs;
p->pObjs = ABC_ALLOC( Dar_LibObj_t, nObjs );
memset( p->pObjs, 0, sizeof(Dar_LibObj_t) * nObjs );
// allocate canonical data
p->pPerms4 = Dar_Permutations( 4 );
Dar_Truth4VarNPN( &p->puCanons, &p->pPhases, &p->pPerms, &p->pMap );
// start the elementary objects
p->iObj = 4;
for ( i = 0; i < 4; i++ )
{
p->pObjs[i].fTerm = 1;
p->pObjs[i].Num = uTruths[i];
}
// ABC_PRT( "Library start", clock() - clk );
return p;
}