abcFunc.c File Reference

#include "abc.h"
#include "base/main/main.h"
#include "map/mio/mio.h"

Include dependency graph for abcFunc.c:

Go to the source code of this file.

Macros
#define	ABC_MAX_CUBES   1000000
	DECLARATIONS ///.
#define	ABC_MAX_CUBES2   10000

Functions
int	Abc_NtkSopToBdd (Abc_Ntk_t *pNtk)
int	Abc_NtkBddToSop (Abc_Ntk_t *pNtk, int fMode, int nCubeLimit, int fCubeSort)
void	Abc_NodeBddToCnf (Abc_Obj_t *pNode, Mem_Flex_t *pMmMan, Vec_Str_t *vCube, int fAllPrimes, char **ppSop0, char **ppSop1)
void	Abc_NtkLogicMakeDirectSops (Abc_Ntk_t *pNtk)
int	Abc_NtkAigToBdd (Abc_Ntk_t *pNtk)
int	Abc_NtkSopToAig (Abc_Ntk_t *pNtk)
Hop_Obj_t *	Abc_ConvertSopToAigInternal (Hop_Man_t *pMan, char *pSop)
void	Abc_ConvertAigToGia_rec1 (Gia_Man_t *p, Hop_Obj_t *pObj)
void	Abc_ConvertAigToGia_rec2 (Hop_Obj_t *pObj)
int	Abc_ConvertAigToGia (Gia_Man_t *p, Hop_Obj_t *pRoot)
Gia_Man_t *	Abc_NtkAigToGia (Abc_Ntk_t *p, int fGiaSimple)
void	Abc_ConvertAigToAig_rec (Abc_Ntk_t *pNtkAig, Hop_Obj_t *pObj)
Abc_Obj_t *	Abc_ConvertAigToAig (Abc_Ntk_t *pNtkAig, Abc_Obj_t *pObjOld)
	DECLARATIONS ///.
int	Abc_NtkMapToSopUsingLibrary (Abc_Ntk_t *pNtk, void *library)
int	Abc_NtkMapToSop (Abc_Ntk_t *pNtk)
int	Abc_NtkSopToBlifMv (Abc_Ntk_t *pNtk)
int	Abc_NtkToSop (Abc_Ntk_t *pNtk, int fMode, int nCubeLimit)
int	Abc_NtkToBdd (Abc_Ntk_t *pNtk)
int	Abc_NtkToAig (Abc_Ntk_t *pNtk)
void	Abc_ObjFaninSort (Abc_Obj_t *pObj)
void	Abc_NtkFaninSort (Abc_Ntk_t *pNtk)

Macro Definition Documentation

ABC_MAX_CUBES

#define ABC_MAX_CUBES   1000000

DECLARATIONS ///.

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

FileName [abcFunc.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Network and node package.]

Synopsis [Transformations between different functionality representations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id

abcFunc.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

]

Definition at line 36 of file abcFunc.c.

ABC_MAX_CUBES2

#define ABC_MAX_CUBES2   10000

Definition at line 37 of file abcFunc.c.

Function Documentation

Abc_ConvertAigToAig()

Abc_Obj_t * Abc_ConvertAigToAig	(	Abc_Ntk_t *	pNtkAig,
		Abc_Obj_t *	pObjOld )

DECLARATIONS ///.

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

Synopsis [Converts the network from AIG to BDD representation.]

Description []

SideEffects []

SeeAlso []

Definition at line 1157 of file abcFunc.c.

{
    Hop_Man_t * pHopMan;
    Hop_Obj_t * pRoot;
    Abc_Obj_t * pFanin;
    int i;
    // get the local AIG
    pHopMan = (Hop_Man_t *)pObjOld->pNtk->pManFunc;
    pRoot = (Hop_Obj_t *)pObjOld->pData;
    // check the case of a constant
    if ( Hop_ObjIsConst1( Hop_Regular(pRoot) ) )
        return Abc_ObjNotCond( Abc_AigConst1(pNtkAig), Hop_IsComplement(pRoot) );
    // assign the fanin nodes
    Abc_ObjForEachFanin( pObjOld, pFanin, i )
    {
        assert( pFanin->pCopy != NULL );
        Hop_ManPi(pHopMan, i)->pData = pFanin->pCopy;
    }
    // construct the AIG
    Abc_ConvertAigToAig_rec( pNtkAig, Hop_Regular(pRoot) );
    Hop_ConeUnmark_rec( Hop_Regular(pRoot) );
    // return the result
    return Abc_ObjNotCond( (Abc_Obj_t *)Hop_Regular(pRoot)->pData, Hop_IsComplement(pRoot) );  
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_ConvertAigToAig_rec()

void Abc_ConvertAigToAig_rec	(	Abc_Ntk_t *	pNtkAig,
		Hop_Obj_t *	pObj )

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

Synopsis [Construct BDDs and mark AIG nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 1134 of file abcFunc.c.

{
    assert( !Hop_IsComplement(pObj) );
    if ( !Hop_ObjIsNode(pObj) || Hop_ObjIsMarkA(pObj) )
        return;
    Abc_ConvertAigToAig_rec( pNtkAig, Hop_ObjFanin0(pObj) ); 
    Abc_ConvertAigToAig_rec( pNtkAig, Hop_ObjFanin1(pObj) );
    pObj->pData = Abc_AigAnd( (Abc_Aig_t *)pNtkAig->pManFunc, (Abc_Obj_t *)Hop_ObjChild0Copy(pObj), (Abc_Obj_t *)Hop_ObjChild1Copy(pObj) ); 
    assert( !Hop_ObjIsMarkA(pObj) ); // loop detection
    Hop_ObjSetMarkA( pObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_ConvertAigToGia()

int Abc_ConvertAigToGia	(	Gia_Man_t *	p,
		Hop_Obj_t *	pRoot )

Definition at line 1029 of file abcFunc.c.

{
    assert( !Hop_IsComplement(pRoot) );
    if ( Hop_ObjIsConst1( pRoot ) )
        return 1;
    Abc_ConvertAigToGia_rec1( p, pRoot );
    Abc_ConvertAigToGia_rec2( pRoot );
    return pRoot->iData;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_ConvertAigToGia_rec1()

void Abc_ConvertAigToGia_rec1	(	Gia_Man_t *	p,
		Hop_Obj_t *	pObj )

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

Synopsis [Converts the network from AIG to GIA representation.]

Description []

SideEffects []

SeeAlso []

Definition at line 1008 of file abcFunc.c.

{
    assert( !Hop_IsComplement(pObj) );
    if ( !Hop_ObjIsNode(pObj) || Hop_ObjIsMarkA(pObj) )
        return;
    Abc_ConvertAigToGia_rec1( p, Hop_ObjFanin0(pObj) ); 
    Abc_ConvertAigToGia_rec1( p, Hop_ObjFanin1(pObj) );
    pObj->iData = Gia_ManAppendAnd2( p, Hop_ObjChild0CopyI(pObj), Hop_ObjChild1CopyI(pObj) );
    assert( !Hop_ObjIsMarkA(pObj) ); // loop detection
    Hop_ObjSetMarkA( pObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_ConvertAigToGia_rec2()

void Abc_ConvertAigToGia_rec2

(

Hop_Obj_t *

pObj

)

Definition at line 1019 of file abcFunc.c.

{
    assert( !Hop_IsComplement(pObj) );
    if ( !Hop_ObjIsNode(pObj) || !Hop_ObjIsMarkA(pObj) )
        return;
    Abc_ConvertAigToGia_rec2( Hop_ObjFanin0(pObj) ); 
    Abc_ConvertAigToGia_rec2( Hop_ObjFanin1(pObj) );
    assert( Hop_ObjIsMarkA(pObj) ); // loop detection
    Hop_ObjClearMarkA( pObj );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_ConvertSopToAigInternal()

Hop_Obj_t * Abc_ConvertSopToAigInternal	(	Hop_Man_t *	pMan,
		char *	pSop )

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

Synopsis [Strashes one logic node using its SOP.]

Description []

SideEffects []

SeeAlso []

Definition at line 934 of file abcFunc.c.

{
    Hop_Obj_t * pAnd, * pSum;
    int i, Value, nFanins;
    char * pCube;
    // get the number of variables
    nFanins = Abc_SopGetVarNum(pSop);
    if ( Abc_SopIsExorType(pSop) )
    {
        pSum = Hop_ManConst0(pMan); 
        for ( i = 0; i < nFanins; i++ )
            pSum = Hop_Exor( pMan, pSum, Hop_IthVar(pMan,i) );
    }
    else
    {
        // go through the cubes of the node's SOP
        pSum = Hop_ManConst0(pMan); 
        Abc_SopForEachCube( pSop, nFanins, pCube )
        {
            // create the AND of literals
            pAnd = Hop_ManConst1(pMan);
            Abc_CubeForEachVar( pCube, Value, i )
            {
                if ( Value == '1' )
                    pAnd = Hop_And( pMan, pAnd, Hop_IthVar(pMan,i) );
                else if ( Value == '0' )
                    pAnd = Hop_And( pMan, pAnd, Hop_Not(Hop_IthVar(pMan,i)) );
            }
            // add to the sum of cubes
            pSum = Hop_Or( pMan, pSum, pAnd );
        }
    }
    // decide whether to complement the result
    if ( Abc_SopIsComplement(pSop) )
        pSum = Hop_Not(pSum);
    return pSum;
}

Here is the call graph for this function:

Abc_NodeBddToCnf()

void Abc_NodeBddToCnf	(	Abc_Obj_t *	pNode,
		Mem_Flex_t *	pMmMan,
		Vec_Str_t *	vCube,
		int	fAllPrimes,
		char **	ppSop0,
		char **	ppSop1 )

Definition at line 867 of file abcFunc.c.

{}

Here is the caller graph for this function:

Abc_NtkAigToBdd()

int Abc_NtkAigToBdd

(

Abc_Ntk_t *

pNtk

)

Definition at line 869 of file abcFunc.c.

{ return 1; }

Here is the caller graph for this function:

Abc_NtkAigToGia()

Gia_Man_t * Abc_NtkAigToGia	(	Abc_Ntk_t *	p,
		int	fGiaSimple )

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

Synopsis [Converts the network from AIG to BDD representation.]

Description []

SideEffects []

SeeAlso []

Definition at line 1050 of file abcFunc.c.

{
    Gia_Man_t * pNew;
    Hop_Man_t * pHopMan;
    Hop_Obj_t * pHopObj;
    Vec_Int_t * vMapping = NULL;
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pNode, * pFanin;
    int i, k, nObjs, iGiaObj;
    assert( Abc_NtkIsAigLogic(p) );
    pHopMan = (Hop_Man_t *)p->pManFunc;
    // create new manager
    pNew = Gia_ManStart( 10000 );
    pNew->pName = Abc_UtilStrsav( Abc_NtkName(p) );
    pNew->pSpec = Abc_UtilStrsav( Abc_NtkSpec(p) );
    pNew->fGiaSimple = fGiaSimple;
    Abc_NtkCleanCopy( p );
    Hop_ManConst1(pHopMan)->iData = 1;
    // create primary inputs
    Abc_NtkForEachCi( p, pNode, i )
        pNode->iTemp = Gia_ManAppendCi(pNew);
    // find the number of objects
    nObjs = 1 + Abc_NtkCiNum(p) + Abc_NtkCoNum(p);
    Abc_NtkForEachNode( p, pNode, i )
        nObjs += Abc_ObjIsBarBuf(pNode) ? 1 : Hop_DagSize( (Hop_Obj_t *)pNode->pData );
    if ( !fGiaSimple )
        vMapping = Vec_IntStart( nObjs );
    // iterate through nodes used in the mapping
    vNodes = Abc_NtkDfs( p, 0 );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i )
    {
        if ( Abc_ObjIsBarBuf(pNode) )
        {
            assert( !Abc_ObjFaninC0(pNode) );
            pNode->iTemp = Gia_ManAppendBuf( pNew, Abc_ObjFanin0(pNode)->iTemp );
            continue;
        }
        Abc_ObjForEachFanin( pNode, pFanin, k )
            Hop_ManPi(pHopMan, k)->iData = pFanin->iTemp;
        pHopObj = Hop_Regular( (Hop_Obj_t *)pNode->pData );
        if ( Hop_DagSize(pHopObj) > 0 )
        {
            assert( Abc_ObjFaninNum(pNode) <= Hop_ManPiNum(pHopMan) );
            Abc_ConvertAigToGia( pNew, pHopObj );
            iGiaObj = Abc_Lit2Var( pHopObj->iData );
            if ( vMapping && Gia_ObjIsAnd(Gia_ManObj(pNew, iGiaObj)) && !Vec_IntEntry(vMapping, iGiaObj) )
            {
                Vec_IntWriteEntry( vMapping, iGiaObj, Vec_IntSize(vMapping) );
                Vec_IntPush( vMapping, Abc_ObjFaninNum(pNode) );
                Abc_ObjForEachFanin( pNode, pFanin, k )
                    Vec_IntPush( vMapping, Abc_Lit2Var(pFanin->iTemp)  );
                Vec_IntPush( vMapping, iGiaObj );
            }
        }
        pNode->iTemp = Abc_LitNotCond( pHopObj->iData, Hop_IsComplement( (Hop_Obj_t *)pNode->pData ) );
    }
    // create primary outputs
    Abc_NtkForEachCo( p, pNode, i )
        Gia_ManAppendCo( pNew, Abc_ObjFanin0(pNode)->iTemp );
    Gia_ManSetRegNum( pNew, Abc_NtkLatchNum(p) );
    // copy original IDs
    pNew->vIdsOrig = Vec_IntStart( Gia_ManObjNum(pNew) );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i )
        Vec_IntWriteEntry( pNew->vIdsOrig, Abc_Lit2Var(pNode->iTemp), Abc_ObjId(pNode) );
    Vec_PtrFree( vNodes );
    // finish mapping 
    assert( Gia_ManObjNum(pNew) <= nObjs );
    assert( pNew->vMapping == NULL );
    pNew->vMapping = vMapping;
    return pNew;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkBddToSop()

int Abc_NtkBddToSop	(	Abc_Ntk_t *	pNtk,
		int	fMode,
		int	nCubeLimit,
		int	fCubeSort )

Definition at line 866 of file abcFunc.c.

{ return 1; }

Here is the caller graph for this function:

Abc_NtkFaninSort()

void Abc_NtkFaninSort

(

Abc_Ntk_t *

pNtk

)

Definition at line 1386 of file abcFunc.c.

{
    Abc_Obj_t * pObj; int i;
    assert( Abc_NtkIsSopLogic(pNtk) );
    Abc_NtkForEachNode( pNtk, pObj, i )
        Abc_ObjFaninSort( pObj );
}

Here is the call graph for this function:

Abc_NtkLogicMakeDirectSops()

void Abc_NtkLogicMakeDirectSops

(

Abc_Ntk_t *

pNtk

)

Definition at line 868 of file abcFunc.c.

{}

Abc_NtkMapToSop()

int Abc_NtkMapToSop

(

Abc_Ntk_t *

pNtk

)

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

Synopsis [Unmaps the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 1228 of file abcFunc.c.

{
    extern void * Abc_FrameReadLibGen();                    
    return Abc_NtkMapToSopUsingLibrary(pNtk, Abc_FrameReadLibGen());
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkMapToSopUsingLibrary()

int Abc_NtkMapToSopUsingLibrary	(	Abc_Ntk_t *	pNtk,
		void *	library )

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

Synopsis [Unmaps the network with user provided Mio library.]

Description []

SideEffects []

SeeAlso []

Definition at line 1194 of file abcFunc.c.

{
    Abc_Obj_t * pNode;
    char * pSop;
    int i;
 
    assert( Abc_NtkHasMapping(pNtk) );
    // update the functionality manager
    assert( pNtk->pManFunc == (void*) library );
    pNtk->pManFunc = Mem_FlexStart();
    // update the nodes
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        if ( Abc_ObjIsBarBuf(pNode) )
            continue;
        pSop = Mio_GateReadSop((Mio_Gate_t *)pNode->pData);
        assert( Abc_SopGetVarNum(pSop) == Abc_ObjFaninNum(pNode) );
        pNode->pData = Abc_SopRegister( (Mem_Flex_t *)pNtk->pManFunc, pSop );
    }
    pNtk->ntkFunc  = ABC_FUNC_SOP;
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkSopToAig()

int Abc_NtkSopToAig

(

Abc_Ntk_t *

pNtk

)

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

Synopsis [Converts the network from SOP to AIG representation.]

Description []

SideEffects []

SeeAlso []

Definition at line 884 of file abcFunc.c.

{
    Abc_Obj_t * pNode;
    Hop_Man_t * pMan;
    int i, Max;
 
    assert( Abc_NtkHasSop(pNtk) ); 
 
    // make dist1-free and SCC-free
//    Abc_NtkMakeLegit( pNtk );
 
    // start the functionality manager
    pMan = Hop_ManStart();
    Max = Abc_NtkGetFaninMax(pNtk);
    if ( Max ) Hop_IthVar( pMan, Max-1 );
 
    // convert each node from SOP to BDD
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        if ( Abc_ObjIsBarBuf(pNode) )
            continue;
        assert( pNode->pData );
        pNode->pData = Abc_ConvertSopToAig( pMan, (char *)pNode->pData );
        if ( pNode->pData == NULL )
        {
            Hop_ManStop( pMan );
            printf( "Abc_NtkSopToAig: Error while converting SOP into AIG.\n" );
            return 0;
        }
    }
    Mem_FlexStop( (Mem_Flex_t *)pNtk->pManFunc, 0 );
    pNtk->pManFunc = pMan;
 
    // update the network type
    pNtk->ntkFunc = ABC_FUNC_AIG;
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkSopToBdd()

int Abc_NtkSopToBdd

(

Abc_Ntk_t *

pNtk

)

Definition at line 865 of file abcFunc.c.

{ return 1; }

Here is the caller graph for this function:

Abc_NtkSopToBlifMv()

int Abc_NtkSopToBlifMv

(

Abc_Ntk_t *

pNtk

)

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

Synopsis [Converts SOP functions into BLIF-MV functions.]

Description []

SideEffects []

SeeAlso []

Definition at line 1245 of file abcFunc.c.

{
    return 1;
}

Abc_NtkToAig()

int Abc_NtkToAig

(

Abc_Ntk_t *

pNtk

)

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

Synopsis [Convers logic network to the SOP form.]

Description []

SideEffects []

SeeAlso []

Definition at line 1333 of file abcFunc.c.

{
    assert( !Abc_NtkIsStrash(pNtk) );
    if ( Abc_NtkHasBlackbox(pNtk) )
        return 1;
    if ( Abc_NtkHasAig(pNtk) )
        return 1;
    if ( Abc_NtkHasMapping(pNtk) )
    {
        Abc_NtkMapToSop(pNtk);
        return Abc_NtkSopToAig(pNtk);
    }
    if ( Abc_NtkHasBdd(pNtk) )
    {
        if ( !Abc_NtkBddToSop(pNtk, -1, ABC_INFINITY, 1) )
            return 0;
        return Abc_NtkSopToAig(pNtk);
    }
    if ( Abc_NtkHasSop(pNtk) )
        return Abc_NtkSopToAig(pNtk);
    assert( 0 );
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkToBdd()

int Abc_NtkToBdd

(

Abc_Ntk_t *

pNtk

)

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

Synopsis [Convers logic network to the SOP form.]

Description []

SideEffects []

SeeAlso []

Definition at line 1299 of file abcFunc.c.

{
    assert( !Abc_NtkIsStrash(pNtk) );
    if ( Abc_NtkHasBlackbox(pNtk) )
        return 1;
    if ( Abc_NtkHasBdd(pNtk) )
        return 1;
    if ( Abc_NtkHasMapping(pNtk) )
    {
        Abc_NtkMapToSop(pNtk);
        return Abc_NtkSopToBdd(pNtk);
    }
    if ( Abc_NtkHasSop(pNtk) )
    {
        Abc_NtkSopToAig(pNtk);
        return Abc_NtkAigToBdd(pNtk);
    }
    if ( Abc_NtkHasAig(pNtk) )
        return Abc_NtkAigToBdd(pNtk);
    assert( 0 );
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkToSop()

int Abc_NtkToSop	(	Abc_Ntk_t *	pNtk,
		int	fMode,
		int	nCubeLimit )

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

Synopsis [Convers logic network to the SOP form.]

Description []

SideEffects []

SeeAlso []

Definition at line 1261 of file abcFunc.c.

{
    assert( !Abc_NtkIsStrash(pNtk) );
    if ( Abc_NtkHasBlackbox(pNtk) )
        return 1;
    if ( Abc_NtkHasSop(pNtk) )
    {
        if ( fMode == -1 )
            return 1;
        if ( !Abc_NtkSopToBdd(pNtk) )
            return 0;
        return Abc_NtkBddToSop(pNtk, fMode, nCubeLimit, 1);
    }
    if ( Abc_NtkHasMapping(pNtk) )
        return Abc_NtkMapToSop(pNtk);
    if ( Abc_NtkHasBdd(pNtk) )
        return Abc_NtkBddToSop(pNtk, fMode, nCubeLimit, 1);
    if ( Abc_NtkHasAig(pNtk) )
    {
        if ( !Abc_NtkAigToBdd(pNtk) )
            return 0;
        return Abc_NtkBddToSop(pNtk, fMode, nCubeLimit, 1);
    }
    assert( 0 );
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_ObjFaninSort()

void Abc_ObjFaninSort

(

Abc_Obj_t *

pObj

)

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1369 of file abcFunc.c.

{
    Vec_Int_t * vFanins = Abc_ObjFaninVec( pObj );
    char * pCube, * pSop = (char*)pObj->pData;
    int i, j, nVars = Abc_SopGetVarNum( pSop );
    assert( nVars == Vec_IntSize(vFanins) );
    for ( i = 0;   i < Vec_IntSize(vFanins); i++ )
    for ( j = i+1; j < Vec_IntSize(vFanins); j++ )
    {
        if ( Vec_IntEntry(vFanins, i) < Vec_IntEntry(vFanins, j) )
            continue;
        ABC_SWAP( int, Vec_IntArray(vFanins)[i], Vec_IntArray(vFanins)[j] );
        for ( pCube = pSop; *pCube; pCube += nVars + 3 ) {
            ABC_SWAP( char, pCube[i], pCube[j] );
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function: