abcMiter.c File Reference

#include "base/abc/abc.h"
#include "base/io/ioAbc.h"
#include "sat/cnf/cnf.h"
#include "sat/bsat/satStore.h"

Include dependency graph for abcMiter.c:

Go to the source code of this file.

Typedefs
typedef void(*	AddFrameMapping) (Abc_Obj_t *, Abc_Obj_t *, int, void *)

Functions
Abc_Ntk_t *	Abc_NtkFrames2 (Abc_Ntk_t *pNtk, int nFrames, int fInitial, AddFrameMapping addFrameMapping, void *arg)
Abc_Ntk_t *	Abc_NtkMiter (Abc_Ntk_t *pNtk1, Abc_Ntk_t *pNtk2, int fComb, int nPartSize, int fImplic, int fMulti)
	FUNCTION DEFINITIONS ///.
void	Abc_NtkMiterAddCone (Abc_Ntk_t *pNtk, Abc_Ntk_t *pNtkMiter, Abc_Obj_t *pRoot)
Abc_Ntk_t *	Abc_NtkMiterAnd (Abc_Ntk_t *pNtk1, Abc_Ntk_t *pNtk2, int fOr, int fCompl2)
Abc_Ntk_t *	Abc_NtkMiterCofactor (Abc_Ntk_t *pNtk, Vec_Int_t *vPiValues)
Abc_Ntk_t *	Abc_NtkMiterForCofactors (Abc_Ntk_t *pNtk, int Out, int In1, int In2)
Abc_Ntk_t *	Abc_NtkMiterQuantify (Abc_Ntk_t *pNtk, int In, int fExist)
Abc_Ntk_t *	Abc_NtkMiterQuantifyPis (Abc_Ntk_t *pNtk)
int	Abc_NtkMiterIsConstant (Abc_Ntk_t *pMiter)
void	Abc_NtkMiterReport (Abc_Ntk_t *pMiter)
Abc_Ntk_t *	Abc_NtkFrames (Abc_Ntk_t *pNtk, int nFrames, int fInitial, int fVerbose)
int	Abc_NtkDemiter (Abc_Ntk_t *pNtk)
int	Abc_NtkCombinePos (Abc_Ntk_t *pNtk, int fAnd, int fXor)
Vec_Ptr_t *	Abc_NtkTryNewMiter (char *pFileName0, char *pFileName1)
Vec_Ptr_t *	Abc_NtkReadNodeNames (Abc_Ntk_t *pNtk, char *pFileName)
Abc_Obj_t *	Abc_NtkSpecialMuxTree_rec (Abc_Ntk_t *pNew, Abc_Obj_t **pCtrl, int nCtrl, Abc_Obj_t **pData, int Shift)
Abc_Ntk_t *	Abc_NtkSpecialMiter (Abc_Ntk_t *pNtk, Vec_Ptr_t *vNodes)

Typedef Documentation

AddFrameMapping

typedef void(* AddFrameMapping) (Abc_Obj_t *, Abc_Obj_t *, int, void *)

Definition at line 40 of file abcMiter.c.

Function Documentation

Abc_NtkCombinePos()

int Abc_NtkCombinePos	(	Abc_Ntk_t *	pNtk,
		int	fAnd,
		int	fXor )

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

Synopsis [Computes OR or AND of the POs.]

Description []

SideEffects []

SeeAlso []

Definition at line 1155 of file abcMiter.c.

{
    Abc_Obj_t * pNode, * pMiter;
    int i;
    assert( Abc_NtkIsStrash(pNtk) );
//    assert( Abc_NtkLatchNum(pNtk) == 0 );
    if ( Abc_NtkPoNum(pNtk) == 1 )
        return 1;
    // start the result
    if ( fAnd )
        pMiter = Abc_AigConst1(pNtk);
    else
        pMiter = Abc_ObjNot( Abc_AigConst1(pNtk) );
    // perform operations on the POs
    Abc_NtkForEachPo( pNtk, pNode, i )
        if ( fAnd )
            pMiter = Abc_AigAnd( (Abc_Aig_t *)pNtk->pManFunc, pMiter, Abc_ObjChild0(pNode) );
        else if ( fXor )
            pMiter = Abc_AigXor( (Abc_Aig_t *)pNtk->pManFunc, pMiter, Abc_ObjChild0(pNode) );
        else
            pMiter = Abc_AigOr( (Abc_Aig_t *)pNtk->pManFunc, pMiter, Abc_ObjChild0(pNode) );
    // remove the POs and their names
    for ( i = Abc_NtkPoNum(pNtk) - 1; i >= 0; i-- )
        Abc_NtkDeleteObj( Abc_NtkPo(pNtk, i) );
    assert( Abc_NtkPoNum(pNtk) == 0 );
    // create the new PO
    pNode = Abc_NtkCreatePo( pNtk );
    Abc_ObjAddFanin( pNode, pMiter );
    Abc_ObjAssignName( pNode, "miter", NULL );
    Abc_NtkOrderCisCos( pNtk );
    // make sure that everything is okay
    if ( !Abc_NtkCheck( pNtk ) )
    {
        printf( "Abc_NtkOrPos: The network check has failed.\n" );
        return 0;
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkDemiter()

int Abc_NtkDemiter

(

Abc_Ntk_t *

pNtk

)

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

Synopsis [Splits the miter into two logic cones combined by an EXOR]

Description []

SideEffects []

SeeAlso []

Definition at line 1087 of file abcMiter.c.

{
    Abc_Obj_t * pNodeC, * pNodeA, * pNodeB, * pNode;
    Abc_Obj_t * pPoNew;
    Vec_Ptr_t * vNodes1, * vNodes2;
    int nCommon, i;
 
    assert( Abc_NtkIsStrash(pNtk) );
    assert( Abc_NtkPoNum(pNtk) == 1 );
    if ( !Abc_NodeIsExorType(Abc_ObjFanin0(Abc_NtkPo(pNtk,0))) )
    {
        printf( "The root of the miter is not an EXOR gate.\n" );
        return 0;
    }
    pNodeC = Abc_NodeRecognizeMux( Abc_ObjFanin0(Abc_NtkPo(pNtk,0)), &pNodeA, &pNodeB );
    assert( Abc_ObjRegular(pNodeA) == Abc_ObjRegular(pNodeB) );
    if ( Abc_ObjFaninC0(Abc_NtkPo(pNtk,0)) )
    {
        pNodeA = Abc_ObjNot(pNodeA);
        pNodeB = Abc_ObjNot(pNodeB);
    }
 
    // add the PO corresponding to control input
    pPoNew = Abc_NtkCreatePo( pNtk );
    Abc_ObjAddFanin( pPoNew, pNodeC );
    Abc_ObjAssignName( pPoNew, "addOut1", NULL );
 
    // add the PO corresponding to other input
    pPoNew = Abc_NtkCreatePo( pNtk );
    Abc_ObjAddFanin( pPoNew, pNodeB );
    Abc_ObjAssignName( pPoNew, "addOut2", NULL );
 
    // mark the nodes in the first cone
    pNodeB = Abc_ObjRegular(pNodeB);
    vNodes1 = Abc_NtkDfsNodes( pNtk, &pNodeC, 1 );
    vNodes2 = Abc_NtkDfsNodes( pNtk, &pNodeB, 1 );
 
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes1, pNode, i )
        pNode->fMarkA = 1;
    nCommon = 0;
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes2, pNode, i )
        nCommon += pNode->fMarkA;
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes1, pNode, i )
        pNode->fMarkA = 0;
 
    printf( "First cone = %6d.  Second cone = %6d.  Common = %6d.\n", vNodes1->nSize, vNodes2->nSize, nCommon );
    Vec_PtrFree( vNodes1 );
    Vec_PtrFree( vNodes2 );
 
    // reorder the latches
    Abc_NtkOrderCisCos( pNtk );
    // make sure that everything is okay
    if ( !Abc_NtkCheck( pNtk ) )
        printf( "Abc_NtkDemiter: The network check has failed.\n" );
    return 1;
}

Here is the call graph for this function:

Abc_NtkFrames()

Abc_Ntk_t * Abc_NtkFrames	(	Abc_Ntk_t *	pNtk,
		int	nFrames,
		int	fInitial,
		int	fVerbose )

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

Synopsis [Derives the timeframes of the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 775 of file abcMiter.c.

{
    char Buffer[1000];
    ProgressBar * pProgress;
    Abc_Ntk_t * pNtkFrames;
    Abc_Obj_t * pLatch, * pLatchOut;
    int i, Counter;
    assert( nFrames > 0 );
    assert( Abc_NtkIsStrash(pNtk) );
    assert( Abc_NtkIsDfsOrdered(pNtk) );
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk) );
    // start the new network
    pNtkFrames = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1 );
    sprintf( Buffer, "%s_%d_frames", pNtk->pName, nFrames );
    pNtkFrames->pName = Extra_UtilStrsav(Buffer);
    // map the constant nodes
    Abc_AigConst1(pNtk)->pCopy = Abc_AigConst1(pNtkFrames);
    
    // create new latches (or their initial values) and remember them in the new latches
    if ( !fInitial )
    {
        Abc_NtkForEachLatch( pNtk, pLatch, i )
            Abc_NtkDupBox( pNtkFrames, pLatch, 1 );
    }
    else
    {
        Counter = 0;
        Abc_NtkForEachLatch( pNtk, pLatch, i )
        {
            pLatchOut = Abc_ObjFanout0(pLatch);
            if ( Abc_LatchIsInitNone(pLatch) || Abc_LatchIsInitDc(pLatch) ) // don't-care initial value - create a new PI
            {
                pLatchOut->pCopy = Abc_NtkCreatePi(pNtkFrames);
                Abc_ObjAssignName( pLatchOut->pCopy, Abc_ObjName(pLatchOut), NULL );
                Counter++;
            }
            else
                pLatchOut->pCopy = Abc_ObjNotCond( Abc_AigConst1(pNtkFrames), Abc_LatchIsInit0(pLatch) );
        }
        if ( Counter )
            printf( "Warning: %d uninitialized latches are replaced by free PI variables.\n", Counter );
    }
    
    // create the timeframes
    pProgress = Extra_ProgressBarStart( stdout, nFrames );
    for ( i = 0; i < nFrames; i++ )
    {
        Extra_ProgressBarUpdate( pProgress, i, NULL );
        Abc_NtkAddFrame( pNtkFrames, pNtk, i );
    }
    Extra_ProgressBarStop( pProgress );
    
    // connect the new latches to the outputs of the last frame
    if ( !fInitial )
    {
        // we cannot use pLatch->pCopy here because pLatch->pCopy is used for temporary storage of strashed values
        Abc_NtkForEachLatch( pNtk, pLatch, i )
            Abc_ObjAddFanin( Abc_ObjFanin0(pLatch)->pCopy, Abc_ObjFanout0(pLatch)->pCopy );
    }
 
    // remove dangling nodes
    Abc_AigCleanup( (Abc_Aig_t *)pNtkFrames->pManFunc );
    // reorder the latches
    Abc_NtkOrderCisCos( pNtkFrames );
    // make sure that everything is okay
    if ( !Abc_NtkCheck( pNtkFrames ) )
    {
        printf( "Abc_NtkFrames: The network check has failed.\n" );
        Abc_NtkDelete( pNtkFrames );
        return NULL;
    }
    return pNtkFrames;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkFrames2()

Abc_Ntk_t * Abc_NtkFrames2 ( Abc_Ntk_t * pNtk, int nFrames, int fInitial, AddFrameMapping addFrameMapping, void * arg )

extern

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

Synopsis [Derives the timeframes of the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 909 of file abcMiter.c.

{
/*
    char Buffer[1000];
    ProgressBar * pProgress;
    Abc_Ntk_t * pNtkFrames;
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pLatch, * pLatchNew;
    int i, Counter;
    assert( nFrames > 0 );
    assert( Abc_NtkIsStrash(pNtk) );   
    // start the new network
    pNtkFrames = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1 );
    sprintf( Buffer, "%s_%d_frames", pNtk->pName, nFrames );
    pNtkFrames->pName = Extra_UtilStrsav(Buffer);
    // create new latches (or their initial values) and remember them in the new latches
    if ( !fInitial )
    {
        Abc_NtkForEachLatch( pNtk, pLatch, i ) {
            Abc_NtkDupObj( pNtkFrames, pLatch );
            if (addFrameMapping) addFrameMapping(pLatch->pCopy, pLatch, 0, arg);
        }
    }
    else
    {
        Counter = 0;
        Abc_NtkForEachLatch( pNtk, pLatch, i )
        {
            if ( Abc_LatchIsInitDc(pLatch) ) // don't-care initial value - create a new PI
            {
                pLatch->pCopy = Abc_NtkCreatePi(pNtkFrames);
                Abc_ObjAssignName( pLatch->pCopy, Abc_ObjName(pLatch), NULL );
                Counter++;
            }
            else {
                pLatch->pCopy = Abc_ObjNotCond( Abc_AigConst1(pNtkFrames), Abc_LatchIsInit0(pLatch) );
            }
 
            if (addFrameMapping) addFrameMapping(pLatch->pCopy, pLatch, 0, arg);
        }
        if ( Counter )
            printf( "Warning: %d uninitialized latches are replaced by free PI variables.\n", Counter );
    }
    
    // create the timeframes
    vNodes = Abc_NtkDfs( pNtk, 0 );
    pProgress = Extra_ProgressBarStart( stdout, nFrames );
    for ( i = 0; i < nFrames; i++ )
    {
        Extra_ProgressBarUpdate( pProgress, i, NULL );
        Abc_NtkAddFrame2( pNtkFrames, pNtk, i, vNodes, addFrameMapping, arg );
    }
    Extra_ProgressBarStop( pProgress );
    Vec_PtrFree( vNodes );
    
    // connect the new latches to the outputs of the last frame
    if ( !fInitial )
    {
        Abc_NtkForEachLatch( pNtk, pLatch, i )
        {
            pLatchNew = Abc_NtkBox(pNtkFrames, i);
            Abc_ObjAddFanin( pLatchNew, pLatch->pCopy );
            Abc_ObjAssignName( pLatchNew, Abc_ObjName(pLatch), NULL );
        }
    }
    Abc_NtkForEachLatch( pNtk, pLatch, i )
        pLatch->pNext = NULL;
 
    // remove dangling nodes
    Abc_AigCleanup( pNtkFrames->pManFunc );
 
    // reorder the latches
    Abc_NtkOrderCisCos( pNtkFrames );
    
    // make sure that everything is okay
    if ( !Abc_NtkCheck( pNtkFrames ) )
    {
        printf( "Abc_NtkFrames: The network check has failed.\n" );
        Abc_NtkDelete( pNtkFrames );
        return NULL;
    }
    return pNtkFrames;
*/
    return NULL;
}

Abc_NtkMiter()

Abc_Ntk_t * Abc_NtkMiter	(	Abc_Ntk_t *	pNtk1,
		Abc_Ntk_t *	pNtk2,
		int	fComb,
		int	nPartSize,
		int	fImplic,
		int	fMulti )

FUNCTION DEFINITIONS ///.

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

Synopsis [Derives the miter of two networks.]

Description [Preprocesses the networks to make sure that they are strashed.]

SideEffects []

SeeAlso []

Definition at line 59 of file abcMiter.c.

{
    Abc_Ntk_t * pTemp = NULL;
    int fRemove1, fRemove2;
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk1) );
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk2) );
    // check that the networks have the same PIs/POs/latches
    if ( !Abc_NtkCompareSignals( pNtk1, pNtk2, fImplic, fComb ) )
        return NULL;
    // make sure the circuits are strashed 
    fRemove1 = (!Abc_NtkIsStrash(pNtk1) || Abc_NtkGetChoiceNum(pNtk1)) && (pNtk1 = Abc_NtkStrash(pNtk1, 0, 0, 0));
    fRemove2 = (!Abc_NtkIsStrash(pNtk2) || Abc_NtkGetChoiceNum(pNtk2)) && (pNtk2 = Abc_NtkStrash(pNtk2, 0, 0, 0));
    if ( pNtk1 && pNtk2 )
        pTemp = Abc_NtkMiterInt( pNtk1, pNtk2, fComb, nPartSize, fImplic, fMulti );
    if ( fRemove1 )  Abc_NtkDelete( pNtk1 );
    if ( fRemove2 )  Abc_NtkDelete( pNtk2 );
    return pTemp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkMiterAddCone()

void Abc_NtkMiterAddCone	(	Abc_Ntk_t *	pNtk,
		Abc_Ntk_t *	pNtkMiter,
		Abc_Obj_t *	pRoot )

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

Synopsis [Performs mitering for one network.]

Description []

SideEffects []

SeeAlso []

Definition at line 254 of file abcMiter.c.

{
    Vec_Ptr_t * vNodes;
    Abc_Obj_t * pNode;
    int i;
    // map the constant nodes
    Abc_AigConst1(pNtk)->pCopy = Abc_AigConst1(pNtkMiter);
    // perform strashing
    vNodes = Abc_NtkDfsNodes( pNtk, &pRoot, 1 );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i )
        if ( Abc_AigNodeIsAnd(pNode) )
            pNode->pCopy = Abc_AigAnd( (Abc_Aig_t *)pNtkMiter->pManFunc, Abc_ObjChild0Copy(pNode), Abc_ObjChild1Copy(pNode) );
    Vec_PtrFree( vNodes );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkMiterAnd()

Abc_Ntk_t * Abc_NtkMiterAnd	(	Abc_Ntk_t *	pNtk1,
		Abc_Ntk_t *	pNtk2,
		int	fOr,
		int	fCompl2 )

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

Synopsis [Derives the AND of two miters.]

Description [The network should have the same names of PIs.]

SideEffects []

SeeAlso []

Definition at line 387 of file abcMiter.c.

{
    char Buffer[1000];
    Abc_Ntk_t * pNtkMiter;
    Abc_Obj_t * pOutput1, * pOutput2;
    Abc_Obj_t * pRoot1, * pRoot2, * pMiter;
 
    assert( Abc_NtkIsStrash(pNtk1) );
    assert( Abc_NtkIsStrash(pNtk2) );
    assert( 1 == Abc_NtkCoNum(pNtk1) );
    assert( 1 == Abc_NtkCoNum(pNtk2) );
    assert( 0 == Abc_NtkLatchNum(pNtk1) );
    assert( 0 == Abc_NtkLatchNum(pNtk2) );
    assert( Abc_NtkCiNum(pNtk1) == Abc_NtkCiNum(pNtk2) );
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk1) );
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk2) );
 
    // start the new network
    pNtkMiter = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1 );
//    sprintf( Buffer, "%s_%s_miter", pNtk1->pName, pNtk2->pName );
    sprintf( Buffer, "product" );
    pNtkMiter->pName = Extra_UtilStrsav(Buffer);
 
    // perform strashing
    Abc_NtkMiterPrepare( pNtk1, pNtk2, pNtkMiter, 1, -1, 0 );
    Abc_NtkMiterAddOne( pNtk1, pNtkMiter );
    Abc_NtkMiterAddOne( pNtk2, pNtkMiter );
//    Abc_NtkMiterFinalize( pNtk1, pNtk2, pNtkMiter, 1 );
    pRoot1 = Abc_NtkPo(pNtk1,0);
    pRoot2 = Abc_NtkPo(pNtk2,0);
    pOutput1 = Abc_ObjNotCond( Abc_ObjFanin0(pRoot1)->pCopy, Abc_ObjFaninC0(pRoot1) );
    pOutput2 = Abc_ObjNotCond( Abc_ObjFanin0(pRoot2)->pCopy, (int)Abc_ObjFaninC0(pRoot2) ^ fCompl2 );
    
    // create the miter of the two outputs
    if ( fOr )
        pMiter = Abc_AigOr( (Abc_Aig_t *)pNtkMiter->pManFunc, pOutput1, pOutput2 );
    else
        pMiter = Abc_AigAnd( (Abc_Aig_t *)pNtkMiter->pManFunc, pOutput1, pOutput2 );
    Abc_ObjAddFanin( Abc_NtkPo(pNtkMiter,0), pMiter );
 
    // make sure that everything is okay
    if ( !Abc_NtkCheck( pNtkMiter ) )
    {
        printf( "Abc_NtkMiterAnd: The network check has failed.\n" );
        Abc_NtkDelete( pNtkMiter );
        return NULL;
    }
    return pNtkMiter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkMiterCofactor()

Abc_Ntk_t * Abc_NtkMiterCofactor	(	Abc_Ntk_t *	pNtk,
		Vec_Int_t *	vPiValues )

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

Synopsis [Derives the cofactor of the miter w.r.t. the set of vars.]

Description [The array of variable values contains -1/0/1 for each PI. -1 means this PI remains, 0/1 means this PI is set to 0/1.]

SideEffects []

SeeAlso []

Definition at line 450 of file abcMiter.c.

{
    char Buffer[1000];
    Abc_Ntk_t * pNtkMiter;
    Abc_Obj_t * pRoot, * pOutput1;
    int Value, i;
 
    assert( Abc_NtkIsStrash(pNtk) );
    assert( 1 == Abc_NtkCoNum(pNtk) );
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk) );
 
    // start the new network
    pNtkMiter = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1 );
    sprintf( Buffer, "%s_miter", pNtk->pName );
    pNtkMiter->pName = Extra_UtilStrsav(Buffer);
 
    // get the root output
    pRoot = Abc_NtkCo( pNtk, 0 );
 
    // perform strashing
    Abc_NtkMiterPrepare( pNtk, pNtk, pNtkMiter, 1, -1, 0 );
    // set the first cofactor
    Vec_IntForEachEntry( vPiValues, Value, i )
    {
        if ( Value == -1 )
            continue;
        if ( Value == 0 )
        {
            Abc_NtkCi(pNtk, i)->pCopy = Abc_ObjNot( Abc_AigConst1(pNtkMiter) );
            continue;
        }
        if ( Value == 1 )
        {
            Abc_NtkCi(pNtk, i)->pCopy = Abc_AigConst1(pNtkMiter);
            continue;
        }
        assert( 0 );
    }
    // add the first cofactor
    Abc_NtkMiterAddCone( pNtk, pNtkMiter, pRoot );
 
    // save the output
    pOutput1 = Abc_ObjNotCond( Abc_ObjFanin0(pRoot)->pCopy, Abc_ObjFaninC0(pRoot) );
 
    // create the miter of the two outputs
    Abc_ObjAddFanin( Abc_NtkPo(pNtkMiter,0), pOutput1 );
 
    // make sure that everything is okay
    if ( !Abc_NtkCheck( pNtkMiter ) )
    {
        printf( "Abc_NtkMiterCofactor: The network check has failed.\n" );
        Abc_NtkDelete( pNtkMiter );
        return NULL;
    }
    return pNtkMiter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkMiterForCofactors()

Abc_Ntk_t * Abc_NtkMiterForCofactors	(	Abc_Ntk_t *	pNtk,
		int	Out,
		int	In1,
		int	In2 )

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

Synopsis [Derives the miter of two cofactors of one output.]

Description []

SideEffects []

SeeAlso []

Definition at line 517 of file abcMiter.c.

{
    char Buffer[1000];
    Abc_Ntk_t * pNtkMiter;
    Abc_Obj_t * pRoot, * pOutput1, * pOutput2, * pMiter;
 
    assert( Abc_NtkIsStrash(pNtk) );
    assert( Out < Abc_NtkCoNum(pNtk) );
    assert( In1 < Abc_NtkCiNum(pNtk) );
    assert( In2 < Abc_NtkCiNum(pNtk) );
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk) );
 
    // start the new network
    pNtkMiter = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1 );
    sprintf( Buffer, "%s_miter", Abc_ObjName(Abc_NtkCo(pNtk, Out)) );
    pNtkMiter->pName = Extra_UtilStrsav(Buffer);
 
    // get the root output
    pRoot = Abc_NtkCo( pNtk, Out );
 
    // perform strashing
    Abc_NtkMiterPrepare( pNtk, pNtk, pNtkMiter, 1, -1, 0 );
    // set the first cofactor
    Abc_NtkCi(pNtk, In1)->pCopy = Abc_ObjNot( Abc_AigConst1(pNtkMiter) );
    if ( In2 >= 0 )
    Abc_NtkCi(pNtk, In2)->pCopy = Abc_AigConst1(pNtkMiter);
    // add the first cofactor
    Abc_NtkMiterAddCone( pNtk, pNtkMiter, pRoot );
 
    // save the output
    pOutput1 = Abc_ObjFanin0(pRoot)->pCopy;
 
    // set the second cofactor
    Abc_NtkCi(pNtk, In1)->pCopy = Abc_AigConst1(pNtkMiter);
    if ( In2 >= 0 )
    Abc_NtkCi(pNtk, In2)->pCopy = Abc_ObjNot( Abc_AigConst1(pNtkMiter) );
    // add the second cofactor
    Abc_NtkMiterAddCone( pNtk, pNtkMiter, pRoot );
 
    // save the output
    pOutput2 = Abc_ObjFanin0(pRoot)->pCopy;
 
    // create the miter of the two outputs
    pMiter = Abc_AigXor( (Abc_Aig_t *)pNtkMiter->pManFunc, pOutput1, pOutput2 );
    Abc_ObjAddFanin( Abc_NtkPo(pNtkMiter,0), pMiter );
 
    // make sure that everything is okay
    if ( !Abc_NtkCheck( pNtkMiter ) )
    {
        printf( "Abc_NtkMiter: The network check has failed.\n" );
        Abc_NtkDelete( pNtkMiter );
        return NULL;
    }
    return pNtkMiter;
}

Here is the call graph for this function:

Abc_NtkMiterIsConstant()

int Abc_NtkMiterIsConstant

(

Abc_Ntk_t *

pMiter

)

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

Synopsis [Checks the status of the miter.]

Description [Return 0 if the miter is sat for at least one output. Return 1 if the miter is unsat for all its outputs. Returns -1 if the miter is undecided for some outputs.]

SideEffects []

SeeAlso []

Definition at line 682 of file abcMiter.c.

{
    Abc_Obj_t * pNodePo, * pChild;
    int i;
    assert( Abc_NtkIsStrash(pMiter) );
    Abc_NtkForEachPo( pMiter, pNodePo, i )
    {
        pChild = Abc_ObjChild0( pNodePo );
        // check if the output is constant 1
        if ( Abc_AigNodeIsConst(pChild) )
        {
            assert( Abc_ObjRegular(pChild) == Abc_AigConst1(pMiter) );
            if ( !Abc_ObjIsComplement(pChild) )
            {
                // if the miter is constant 1, return immediately
//                printf( "MITER IS CONSTANT 1!\n" );
                return 0;
            }
        }
/*
        // check if the output is not constant 0
        else if ( Abc_ObjRegular(pChild)->fPhase != (unsigned)Abc_ObjIsComplement(pChild) )
        {
            return 0;
        }
*/
        // if the miter is undecided (or satisfiable), return immediately
        else 
            return -1;
    }
    // return 1, meaning all outputs are constant zero
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkMiterQuantify()

Abc_Ntk_t * Abc_NtkMiterQuantify	(	Abc_Ntk_t *	pNtk,
		int	In,
		int	fExist )

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

Synopsis [Derives the miter of two cofactors of one output.]

Description []

SideEffects []

SeeAlso []

Definition at line 585 of file abcMiter.c.

{
    Abc_Ntk_t * pNtkMiter;
    Abc_Obj_t * pRoot, * pOutput1, * pOutput2, * pMiter;
 
    assert( Abc_NtkIsStrash(pNtk) );
    assert( 1 == Abc_NtkCoNum(pNtk) );
    assert( In < Abc_NtkCiNum(pNtk) );
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk) );
 
    // start the new network
    pNtkMiter = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1 );
    pNtkMiter->pName = Extra_UtilStrsav( Abc_ObjName(Abc_NtkCo(pNtk, 0)) );
 
    // get the root output
    pRoot = Abc_NtkCo( pNtk, 0 );
 
    // perform strashing
    Abc_NtkMiterPrepare( pNtk, pNtk, pNtkMiter, 1, -1, 0 );
    // set the first cofactor
    Abc_NtkCi(pNtk, In)->pCopy = Abc_ObjNot( Abc_AigConst1(pNtkMiter) );
    // add the first cofactor
    Abc_NtkMiterAddCone( pNtk, pNtkMiter, pRoot );
    // save the output
//    pOutput1 = Abc_ObjFanin0(pRoot)->pCopy;
    pOutput1 = Abc_ObjNotCond( Abc_ObjFanin0(pRoot)->pCopy, Abc_ObjFaninC0(pRoot) );
 
    // set the second cofactor
    Abc_NtkCi(pNtk, In)->pCopy = Abc_AigConst1(pNtkMiter);
    // add the second cofactor
    Abc_NtkMiterAddCone( pNtk, pNtkMiter, pRoot );
    // save the output
//    pOutput2 = Abc_ObjFanin0(pRoot)->pCopy;
    pOutput2 = Abc_ObjNotCond( Abc_ObjFanin0(pRoot)->pCopy, Abc_ObjFaninC0(pRoot) );
 
    // create the miter of the two outputs
    if ( fExist ) 
        pMiter = Abc_AigOr( (Abc_Aig_t *)pNtkMiter->pManFunc, pOutput1, pOutput2 );
    else
        pMiter = Abc_AigAnd( (Abc_Aig_t *)pNtkMiter->pManFunc, pOutput1, pOutput2 );
    Abc_ObjAddFanin( Abc_NtkPo(pNtkMiter,0), pMiter );
 
    // make sure that everything is okay
    if ( !Abc_NtkCheck( pNtkMiter ) )
    {
        printf( "Abc_NtkMiter: The network check has failed.\n" );
        Abc_NtkDelete( pNtkMiter );
        return NULL;
    }
    return pNtkMiter;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkMiterQuantifyPis()

Abc_Ntk_t * Abc_NtkMiterQuantifyPis

(

Abc_Ntk_t *

pNtk

)

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

Synopsis [Quantifies all the PIs existentially from the only PO of the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 648 of file abcMiter.c.

{
    Abc_Ntk_t * pNtkTemp;
    Abc_Obj_t * pObj;
    int i;
    assert( Abc_NtkHasOnlyLatchBoxes(pNtk) );
 
    Abc_NtkForEachPi( pNtk, pObj, i )
    {
        if ( Abc_ObjFanoutNum(pObj) == 0 )
            continue;
        pNtk = Abc_NtkMiterQuantify( pNtkTemp = pNtk, i, 1 );
        Abc_NtkDelete( pNtkTemp );
    }
 
    return pNtk;
}

Here is the call graph for this function:

Abc_NtkMiterReport()

void Abc_NtkMiterReport

(

Abc_Ntk_t *

pMiter

)

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

Synopsis [Reports the status of the miter.]

Description []

SideEffects []

SeeAlso []

Definition at line 727 of file abcMiter.c.

{
    Abc_Obj_t * pChild, * pNode;
    int i;
    if ( Abc_NtkPoNum(pMiter) == 1 )
    {
        pChild = Abc_ObjChild0( Abc_NtkPo(pMiter,0) );
        if ( Abc_AigNodeIsConst(pChild) )
        {
            if ( Abc_ObjIsComplement(pChild) )
                printf( "Unsatisfiable.\n" );
            else
                printf( "Satisfiable. (Constant 1).\n" );
        }
        else
            printf( "Satisfiable.\n" );
    }
    else
    {
        Abc_NtkForEachPo( pMiter, pNode, i )
        {
            pChild = Abc_ObjChild0( Abc_NtkPo(pMiter,i) );
            printf( "Output #%2d : ", i );
            if ( Abc_AigNodeIsConst(pChild) )
            {
                if ( Abc_ObjIsComplement(pChild) )
                    printf( "Unsatisfiable.\n" );
                else
                    printf( "Satisfiable. (Constant 1).\n" );
            }
            else
                printf( "Satisfiable.\n" );
        }
    }
}

Abc_NtkReadNodeNames()

Vec_Ptr_t * Abc_NtkReadNodeNames	(	Abc_Ntk_t *	pNtk,
		char *	pFileName )

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

Synopsis [Read node names.]

Description []

SideEffects []

SeeAlso []

Definition at line 1261 of file abcMiter.c.

{
    char Buffer[1000];
    Vec_Ptr_t * vNodes = NULL;
    FILE * pFile = fopen( pFileName, "rb" );
    if ( pFile == NULL )
    {
        printf( "Cannot open node list \"%s\".\n", pFileName );
        return NULL;
    }
    vNodes = Vec_PtrAlloc( 100 );
    while ( fgets(Buffer, 1000, pFile) != NULL ) 
    {
        char * pToken = strtok( Buffer, " \n\r\t" );
        while ( pToken )
        {
            Abc_Obj_t * pObj = Abc_NtkFindNode( pNtk, pToken );
            if ( pObj == NULL )
            {
                printf( "Cannot find node \"%s\".\n", pToken );
                Vec_PtrFree( vNodes );
                fclose( pFile );
                return NULL;
            }
            Vec_PtrPush( vNodes, pObj );
            pToken = strtok( NULL, " \n\r\t" );
        }
    }
    fclose( pFile );
    return vNodes;
}

Here is the call graph for this function:

Abc_NtkSpecialMiter()

Abc_Ntk_t * Abc_NtkSpecialMiter	(	Abc_Ntk_t *	pNtk,
		Vec_Ptr_t *	vNodes )

Definition at line 1313 of file abcMiter.c.

{
    Abc_Ntk_t * pNtkNew;
    Abc_Obj_t * pObj, * pFanin, * pObjNew, * pPoNew; char * pName; 
    Vec_Int_t * vFirsts = Vec_IntAlloc( Vec_PtrSize(vNodes) );
    Vec_Ptr_t * vNames  = Vec_PtrAlloc( 100 );
    Vec_Ptr_t * vFanins = Vec_PtrAlloc( 100 );
    Vec_Ptr_t * vDatas  = Vec_PtrAlloc( 100 );
    Vec_Ptr_t * vDfs    = Abc_NtkDfs( pNtk, 1 );
    Vec_Ptr_t * vCopies = Vec_PtrStart( Abc_NtkObjNumMax(pNtk) );
    int i, k, Index, First, nNewPis = 0;
    // count the number of additional inputs
    Abc_NtkCleanCopy( pNtk );
    Abc_NtkCleanMarkA( pNtk );
    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
    {
        char Buffer[1000];
        assert( Abc_ObjIsNode(pObj) );
        pObj->fMarkA = 1;
        Vec_IntPush( vFirsts, nNewPis );
        nNewPis += 1 << Abc_ObjFaninNum(pObj);
        for ( k = 0; k < (1 << Abc_ObjFaninNum(pObj)); k++ )
        {
            sprintf( Buffer, "pi_%s_%d", Abc_ObjName(pObj), k );
            Vec_PtrPush( vNames, Abc_UtilStrsav(Buffer) );
        }
    }
    // create new network with the additional PIs
    pNtkNew = Abc_NtkAlloc( pNtk->ntkType, pNtk->ntkFunc, 1 );
    pNtkNew->pName = Extra_UtilStrsav( "miter" );
    Vec_PtrForEachEntry( char *, vNames, pName, i )
        Abc_ObjAssignName( Abc_NtkCreatePi(pNtkNew), pName, NULL );
    // duplicate PIs
    Abc_NtkForEachCi( pNtk, pObj, i )
        pObj->pCopy = Abc_NtkDupObj( pNtkNew, pObj, 1 );
    // copy nodes
    Vec_PtrForEachEntry( Abc_Obj_t *, vDfs, pObj, i )
    {
        if ( !pObj->fMarkA )
        {
            Abc_NtkDupObj( pNtkNew, pObj, 1 );
            Abc_ObjForEachFanin( pObj, pFanin, k )
                Abc_ObjAddFanin( pObj->pCopy, pFanin->pCopy );
            Vec_PtrWriteEntry( vCopies, pObj->Id, pObj->pCopy );
            continue;
        }
        Vec_PtrClear( vFanins );
        Abc_ObjForEachFanin( pObj, pFanin, k )
            Vec_PtrPush( vFanins, pFanin->pCopy );
        Index = Vec_PtrFind( vNodes, pObj );
        assert( Index >= 0 );
        First = Vec_IntEntry( vFirsts, Index );
        Vec_PtrClear( vDatas );
        for ( k = 0; k < (1 << Abc_ObjFaninNum(pObj)); k++ )
            Vec_PtrPush( vDatas, Abc_NtkCi(pNtkNew, First + k) );
        pObj->pCopy = Abc_NtkSpecialMuxTree_rec( pNtkNew, 
            (Abc_Obj_t **)Vec_PtrArray(vFanins), Vec_PtrSize(vFanins), 
            (Abc_Obj_t **)Vec_PtrArray(vDatas),  0 ); 
        Vec_PtrWriteEntry( vCopies, pObj->Id, pObj->pCopy );
    }
    Vec_PtrForEachEntry( Abc_Obj_t *, vDfs, pObj, i )
    {
        pObj->fMarkA = 0;
        Abc_NtkDupObj( pNtkNew, pObj, 0 );
        Abc_ObjAssignName( pObj->pCopy, Abc_ObjName(pObj), "_copy" );
        Abc_ObjForEachFanin( pObj, pFanin, k )
            Abc_ObjAddFanin( pObj->pCopy, pFanin->pCopy );
    }
    // create miter
    Vec_PtrClear( vDatas );
    Abc_NtkForEachCo( pNtk, pObj, i )
    {
        Vec_PtrClear( vFanins );
        Vec_PtrPush( vFanins, Abc_ObjFanin0(pObj)->pCopy );
        Vec_PtrPush( vFanins, (Abc_Obj_t *)Vec_PtrEntry(vCopies, Abc_ObjId(Abc_ObjFanin0(pObj))) );
        Vec_PtrPush( vDatas, Abc_NtkCreateNodeExor(pNtkNew, vFanins) );
    }
    if ( Vec_PtrSize(vDatas) > 1 )
        pObjNew = Abc_NtkCreateNodeOr( pNtkNew, vDatas );
    else
        pObjNew = (Abc_Obj_t *)Vec_PtrEntry(vDatas, 0);
    Abc_ObjAddFanin( (pPoNew = Abc_NtkCreatePo(pNtkNew)), pObjNew );
    Abc_ObjAssignName( pPoNew, "miter_output", NULL );
    // cleanup
    Vec_IntFree( vFirsts );
    Vec_PtrFreeFree( vNames );
    Vec_PtrFree( vFanins );
    Vec_PtrFree( vDatas );
    Vec_PtrFree( vDfs );
    Vec_PtrFree( vCopies );
    return pNtkNew;
}

Here is the call graph for this function:

Abc_NtkSpecialMuxTree_rec()

Abc_Obj_t * Abc_NtkSpecialMuxTree_rec	(	Abc_Ntk_t *	pNew,
		Abc_Obj_t **	pCtrl,
		int	nCtrl,
		Abc_Obj_t **	pData,
		int	Shift )

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

Synopsis [Deriving specialized miter.]

Description []

SideEffects []

SeeAlso []

Definition at line 1304 of file abcMiter.c.

{
    Abc_Obj_t * pLit0, * pLit1;
    if ( nCtrl == 0 )
        return pData[Shift];
    pLit0 = Abc_NtkSpecialMuxTree_rec( pNew, pCtrl, nCtrl-1, pData, Shift );
    pLit1 = Abc_NtkSpecialMuxTree_rec( pNew, pCtrl, nCtrl-1, pData, Shift + (1<<(nCtrl-1)) );
    return Abc_NtkCreateNodeMux( pNew, pCtrl[nCtrl-1], pLit1, pLit0 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkTryNewMiter()

Vec_Ptr_t * Abc_NtkTryNewMiter	(	char *	pFileName0,
		char *	pFileName1 )

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

Synopsis [Miter construction for two networks.]

Description []

SideEffects []

SeeAlso []

Definition at line 1205 of file abcMiter.c.

{
    extern void * Cnf_DataWriteIntoSolver2( Cnf_Dat_t * p, int nFrames, int fInit );
    int i, nVars, * pVars, iCiVarBeg, iCoVarBeg = 1, nBTLimit = 100000;
    sat_solver * pSat  = NULL;
    Cnf_Dat_t * pCnf   = NULL;
    Vec_Ptr_t * vCexes = NULL;
    Abc_Ntk_t * pNtk1  = Io_Read( pFileName0, IO_FILE_VERILOG, 1, 0 );
    Abc_Ntk_t * pNtk2  = Io_Read( pFileName1, IO_FILE_VERILOG, 1, 0 );
    Abc_Ntk_t * pNtk1_ = Abc_NtkStrash( pNtk1, 1, 1, 0 );
    Abc_Ntk_t * pNtk2_ = Abc_NtkStrash( pNtk2, 1, 1, 0 );
    Abc_Ntk_t * pMiter = Abc_NtkMiter( pNtk1_, pNtk2_, 1, 0, 0, 1 );
    Gia_Man_t * pGia = Abc_NtkClpGia( pMiter );
    assert( Abc_NtkCiNum(pNtk1) == Abc_NtkCiNum(pNtk2) );
    assert( Abc_NtkCoNum(pNtk1) == Abc_NtkCoNum(pNtk2) );
    Abc_NtkDelete( pNtk1 );
    Abc_NtkDelete( pNtk2 );
    Abc_NtkDelete( pNtk1_ );
    Abc_NtkDelete( pNtk2_ );
    Abc_NtkDelete( pMiter );
    vCexes = Vec_PtrStart( Gia_ManPoNum(pGia) );
    pCnf = (Cnf_Dat_t *)Mf_ManGenerateCnf( pGia, 8, 0, 0, 0, 0 );
    nVars = Gia_ManPiNum(pGia);
    iCiVarBeg = pCnf->nVars - nVars;
    pVars = ABC_ALLOC( int, nVars );
    for ( i = 0; i < nVars; i++ )
        pVars[i] = iCiVarBeg + i;
    pSat = (sat_solver *)Cnf_DataWriteIntoSolver(pCnf, 1, 0);
    Cnf_DataFree( pCnf );
    for ( i = 0; i < Gia_ManPoNum(pGia); i++ )
    {
        int Lit = Abc_Var2Lit( iCoVarBeg + i, 0 );
        int status = sat_solver_solve( pSat, &Lit, &Lit + 1, nBTLimit, 0, 0, 0 );
        assert( status != l_Undef );
        if ( status == l_False )
            continue;
        Vec_PtrWriteEntry( vCexes, i, Sat_SolverGetModel(pSat, pVars, nVars) );
        printf( "Output %3d (out of %3d) is SAT.\n", i, Gia_ManPoNum(pGia) );
    }
    Gia_ManStop( pGia );
    sat_solver_delete( pSat );
    ABC_FREE( pVars );
    return vCexes;
}

Here is the call graph for this function: