ntlnwk.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
typedef typedefABC_NAMESPACE_HEADER_START struct Ntl_Man_t_	Ntl_Man_t
	INCLUDES ///.
typedef struct Nwk_Man_t_	Nwk_Man_t

Functions
ABC_DLL Ntl_Man_t *	Ntl_ManReadBlif (char *pFileName, int fCheck)
	MACRO DEFINITIONS ///.
ABC_DLL void	Ntl_ManWriteBlif (Ntl_Man_t *p, char *pFileName)
ABC_DLL Tim_Man_t *	Ntl_ManReadTimeMan (Ntl_Man_t *p)
ABC_DLL Ntl_Man_t *	Ntl_ManDup (Ntl_Man_t *p)
ABC_DLL void	Ntl_ManFree (Ntl_Man_t *p)
ABC_DLL int	Ntl_ManIsComb (Ntl_Man_t *p)
ABC_DLL void	Ntl_ManPrintStats (Ntl_Man_t *p)
ABC_DLL int	Ntl_ManSweep (Ntl_Man_t *p, int fVerbose)
ABC_DLL Ntl_Man_t *	Ntl_ManInsertNtk (Ntl_Man_t *p, Nwk_Man_t *pNtk)
ABC_DLL Ntl_Man_t *	Ntl_ManInsertAig (Ntl_Man_t *p, Aig_Man_t *pAig)
ABC_DLL Aig_Man_t *	Ntl_ManExtract (Ntl_Man_t *p)
ABC_DLL Aig_Man_t *	Ntl_ManCollapse (Ntl_Man_t *p, int fSeq)
ABC_DLL Aig_Man_t *	Ntl_ManCollapseSeq (Ntl_Man_t *p, int nMinDomSize, int fVerbose)
ABC_DLL Ntl_Man_t *	Ntl_ManDupCollapseLuts (Ntl_Man_t *p)
ABC_DLL Ntl_Man_t *	Ntl_ManFraig (Ntl_Man_t *p, int nPartSize, int nConfLimit, int nLevelMax, int fUseCSat, int fVerbose)
ABC_DLL void	Ntl_ManPrepareCecMans (Ntl_Man_t *pMan1, Ntl_Man_t *pMan2, Aig_Man_t **ppAig1, Aig_Man_t **ppAig2)
ABC_DLL Vec_Ptr_t *	Ntl_ManCollectCiNames (Ntl_Man_t *p)
ABC_DLL Vec_Ptr_t *	Ntl_ManCollectCoNames (Ntl_Man_t *p)
ABC_DLL Ntl_Man_t *	Ntl_ManScl (Ntl_Man_t *p, int fLatchConst, int fLatchEqual, int fVerbose)
ABC_DLL Ntl_Man_t *	Ntl_ManLcorr (Ntl_Man_t *p, int nConfMax, int fScorrGia, int fUseCSat, int fVerbose)
ABC_DLL Ntl_Man_t *	Ntl_ManSsw (Ntl_Man_t *p, Fra_Ssw_t *pPars)
ABC_DLL Ntl_Man_t *	Ntl_ManScorr (Ntl_Man_t *p, Ssw_Pars_t *pPars)
ABC_DLL void	Ntl_ManTransformInitValues (Ntl_Man_t *p)
ABC_DLL void	Ntl_ManPrepareCec (char *pFileName1, char *pFileName2, Aig_Man_t **ppMan1, Aig_Man_t **ppMan2)
ABC_DLL Aig_Man_t *	Ntl_ManPrepareSec (char *pFileName1, char *pFileName2)
ABC_DLL Nwk_Man_t *	Ntl_ManExtractNwk (Ntl_Man_t *p, Aig_Man_t *pAig, Tim_Man_t *pManTime)
ABC_DLL Nwk_Man_t *	Ntl_ManReadNwk (char *pFileName, Aig_Man_t *pAig, Tim_Man_t *pManTime)
ABC_DLL void	Nwk_ManPrintStats (Nwk_Man_t *p, If_LibLut_t *pLutLib, int fSaveBest, int fDumpResult, int fPower, Ntl_Man_t *pNtl)
ABC_DLL void	Nwk_ManPrintStatsShort (Ntl_Man_t *p, Aig_Man_t *pAig, Nwk_Man_t *pNtk)
ABC_DLL void	Nwk_ManPrintFanioNew (Nwk_Man_t *p)
ABC_DLL Nwk_Man_t *	Nwk_MappingIf (Aig_Man_t *p, Tim_Man_t *pManTime, If_Par_t *pPars)
ABC_DLL void	Nwk_ManSetIfParsDefault (If_Par_t *pPars)
	DECLARATIONS ///.
ABC_DLL void	Nwk_ManBidecResyn (Nwk_Man_t *p, int fVerbose)
ABC_DLL Aig_Man_t *	Nwk_ManSpeedup (Nwk_Man_t *p, int fUseLutLib, int Percentage, int Degree, int fVerbose, int fVeryVerbose)
ABC_DLL Aig_Man_t *	Nwk_ManStrash (Nwk_Man_t *p)
ABC_DLL Vec_Int_t *	Nwk_ManLutMerge (Nwk_Man_t *p, void *pPars)
ABC_DLL int	Nwk_ManCheck (Nwk_Man_t *p)
	DECLARATIONS ///.
ABC_DLL void	Nwk_ManDumpBlif (Nwk_Man_t *p, char *pFileName, Vec_Ptr_t *vCiNames, Vec_Ptr_t *vCoNames)
ABC_DLL void	Nwk_ManFree (Nwk_Man_t *p)

Typedef Documentation

Ntl_Man_t

typedef typedefABC_NAMESPACE_HEADER_START struct Ntl_Man_t_ Ntl_Man_t

INCLUDES ///.

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

FileName [ntlnwk.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Netlist and network representation.]

Synopsis [External declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id

ntlnwk.h,v 1.3 2008/10/24 14:18:44 mjarvin Exp

] PARAMETERS /// BASIC TYPES ///

Definition at line 40 of file ntlnwk.h.

Nwk_Man_t

typedef struct Nwk_Man_t_ Nwk_Man_t

Definition at line 41 of file ntlnwk.h.

Function Documentation

Ntl_ManCollapse()

ABC_DLL Aig_Man_t * Ntl_ManCollapse ( Ntl_Man_t * p, int fSeq )

extern

Ntl_ManCollapseSeq()

ABC_DLL Aig_Man_t * Ntl_ManCollapseSeq ( Ntl_Man_t * p, int nMinDomSize, int fVerbose )

extern

Ntl_ManCollectCiNames()

ABC_DLL Vec_Ptr_t * Ntl_ManCollectCiNames ( Ntl_Man_t * p )

extern

Ntl_ManCollectCoNames()

ABC_DLL Vec_Ptr_t * Ntl_ManCollectCoNames ( Ntl_Man_t * p )

extern

Ntl_ManDup()

ABC_DLL Ntl_Man_t * Ntl_ManDup ( Ntl_Man_t * p )

extern

Ntl_ManDupCollapseLuts()

ABC_DLL Ntl_Man_t * Ntl_ManDupCollapseLuts ( Ntl_Man_t * p )

extern

Ntl_ManExtract()

ABC_DLL Aig_Man_t * Ntl_ManExtract ( Ntl_Man_t * p )

extern

Ntl_ManExtractNwk()

ABC_DLL Nwk_Man_t * Ntl_ManExtractNwk ( Ntl_Man_t * p, Aig_Man_t * pAig, Tim_Man_t * pManTime )

extern

Ntl_ManFraig()

ABC_DLL Ntl_Man_t * Ntl_ManFraig ( Ntl_Man_t * p, int nPartSize, int nConfLimit, int nLevelMax, int fUseCSat, int fVerbose )

extern

Ntl_ManFree()

ABC_DLL void Ntl_ManFree ( Ntl_Man_t * p )

extern

Ntl_ManInsertAig()

ABC_DLL Ntl_Man_t * Ntl_ManInsertAig ( Ntl_Man_t * p, Aig_Man_t * pAig )

extern

Ntl_ManInsertNtk()

ABC_DLL Ntl_Man_t * Ntl_ManInsertNtk ( Ntl_Man_t * p, Nwk_Man_t * pNtk )

extern

Ntl_ManIsComb()

ABC_DLL int Ntl_ManIsComb ( Ntl_Man_t * p )

extern

Ntl_ManLcorr()

ABC_DLL Ntl_Man_t * Ntl_ManLcorr ( Ntl_Man_t * p, int nConfMax, int fScorrGia, int fUseCSat, int fVerbose )

extern

Ntl_ManPrepareCec()

ABC_DLL void Ntl_ManPrepareCec ( char * pFileName1, char * pFileName2, Aig_Man_t ** ppMan1, Aig_Man_t ** ppMan2 )

extern

Ntl_ManPrepareCecMans()

ABC_DLL void Ntl_ManPrepareCecMans ( Ntl_Man_t * pMan1, Ntl_Man_t * pMan2, Aig_Man_t ** ppAig1, Aig_Man_t ** ppAig2 )

extern

Ntl_ManPrepareSec()

ABC_DLL Aig_Man_t * Ntl_ManPrepareSec ( char * pFileName1, char * pFileName2 )

extern

Ntl_ManPrintStats()

ABC_DLL void Ntl_ManPrintStats ( Ntl_Man_t * p )

extern

Ntl_ManReadBlif()

ABC_DLL Ntl_Man_t * Ntl_ManReadBlif ( char * pFileName, int fCheck )

extern

MACRO DEFINITIONS ///.

INLINED FUNCTIONS /// ITERATORS /// FUNCTION DECLARATIONS ///

Ntl_ManReadNwk()

ABC_DLL Nwk_Man_t * Ntl_ManReadNwk ( char * pFileName, Aig_Man_t * pAig, Tim_Man_t * pManTime )

extern

Ntl_ManReadTimeMan()

ABC_DLL Tim_Man_t * Ntl_ManReadTimeMan ( Ntl_Man_t * p )

extern

Ntl_ManScl()

ABC_DLL Ntl_Man_t * Ntl_ManScl ( Ntl_Man_t * p, int fLatchConst, int fLatchEqual, int fVerbose )

extern

Ntl_ManScorr()

ABC_DLL Ntl_Man_t * Ntl_ManScorr ( Ntl_Man_t * p, Ssw_Pars_t * pPars )

extern

Ntl_ManSsw()

ABC_DLL Ntl_Man_t * Ntl_ManSsw ( Ntl_Man_t * p, Fra_Ssw_t * pPars )

extern

Ntl_ManSweep()

ABC_DLL int Ntl_ManSweep ( Ntl_Man_t * p, int fVerbose )

extern

Ntl_ManTransformInitValues()

ABC_DLL void Ntl_ManTransformInitValues ( Ntl_Man_t * p )

extern

Ntl_ManWriteBlif()

ABC_DLL void Ntl_ManWriteBlif ( Ntl_Man_t * p, char * pFileName )

extern

Nwk_ManBidecResyn()

ABC_DLL void Nwk_ManBidecResyn ( Nwk_Man_t * pNtk, int fVerbose )

extern

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

Synopsis [Resynthesizes nodes using bi-decomposition.]

Description []

SideEffects []

SeeAlso []

Definition at line 129 of file nwkBidec.c.

{
    Bdc_Par_t Pars = {0}, * pPars = &Pars;
    Bdc_Man_t * p;
    Nwk_Obj_t * pObj;
    Vec_Int_t * vTruth;
    int i, nGainTotal = 0, nNodes1, nNodes2;
    abctime clk = Abc_Clock();
    pPars->nVarsMax = Nwk_ManGetFaninMax( pNtk );
    pPars->fVerbose = fVerbose;
    if ( pPars->nVarsMax < 2 )
    {
        printf( "Resynthesis is not performed for networks whose nodes are less than 2 inputs.\n" );
        return;
    }
    if ( pPars->nVarsMax > 15 )
    {
        if ( fVerbose )
        printf( "Resynthesis is not performed for nodes with more than 15 inputs.\n" );
        pPars->nVarsMax = 15;
    }
    vTruth = Vec_IntAlloc( 0 );
    p = Bdc_ManAlloc( pPars );
    Nwk_ManForEachNode( pNtk, pObj, i )
    {
        if ( Nwk_ObjFaninNum(pObj) > 15 )
            continue;
        nNodes1 = Hop_DagSize(pObj->pFunc);
        pObj->pFunc = Nwk_NodeIfNodeResyn( p, pNtk->pManHop, pObj->pFunc, Nwk_ObjFaninNum(pObj), vTruth, NULL, -1.0 );
        nNodes2 = Hop_DagSize(pObj->pFunc);
        nGainTotal += nNodes1 - nNodes2;
    }
    Bdc_ManFree( p );
    Vec_IntFree( vTruth );
    if ( fVerbose )
    {
    printf( "Total gain in AIG nodes = %d.  ", nGainTotal );
    ABC_PRT( "Total runtime", Abc_Clock() - clk );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Nwk_ManCheck()

ABC_DLL int Nwk_ManCheck ( Nwk_Man_t * p )

extern

DECLARATIONS ///.

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

FileName [nwkCheck.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Logic network representation.]

Synopsis [Consistency checking procedures.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id

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

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Checking the logic network for consistency.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file nwkCheck.c.

{
    Nwk_Obj_t * pObj, * pNext;
    int i, k, m;
    // check if the nodes have duplicated fanins
    Nwk_ManForEachNode( p, pObj, i )
    {
        for ( k = 0; k < pObj->nFanins; k++ )
            for ( m = k + 1; m < pObj->nFanins; m++ )
                if ( pObj->pFanio[k] == pObj->pFanio[m] )
                    printf( "Node %d has duplicated fanin %d.\n", pObj->Id, pObj->pFanio[k]->Id );
    }
    // check if all nodes are in the correct fanin/fanout relationship
    Nwk_ManForEachObj( p, pObj, i )
    {
        Nwk_ObjForEachFanin( pObj, pNext, k )
            if ( Nwk_ObjFanoutNum(pNext) < 100 && Nwk_ObjFindFanout( pNext, pObj ) == -1 )
                printf( "Nwk_ManCheck(): Object %d has fanin %d which does not have a corresponding fanout.\n", pObj->Id, pNext->Id );
        Nwk_ObjForEachFanout( pObj, pNext, k )
            if ( Nwk_ObjFindFanin( pNext, pObj ) == -1 )
                printf( "Nwk_ManCheck(): Object %d has fanout %d which does not have a corresponding fanin.\n", pObj->Id, pNext->Id );
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Nwk_ManDumpBlif()

ABC_DLL void Nwk_ManDumpBlif ( Nwk_Man_t * pNtk, char * pFileName, Vec_Ptr_t * vPiNames, Vec_Ptr_t * vPoNames )

extern

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

Synopsis [Dumps the BLIF file for the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 257 of file nwkUtil.c.

{
    FILE * pFile;
    Vec_Ptr_t * vNodes;
    Vec_Int_t * vTruth;
    Vec_Int_t * vCover;
    Nwk_Obj_t * pObj, * pFanin;
    Aig_MmFlex_t * pMem;
    char * pSop = NULL;
    unsigned * pTruth;
    int i, k, nDigits;
    if ( Nwk_ManPoNum(pNtk) == 0 )
    {
        printf( "Nwk_ManDumpBlif(): Network does not have POs.\n" );
        return;
    }
    // collect nodes in the DFS order
    nDigits = Abc_Base10Log( Nwk_ManObjNumMax(pNtk) );
    // write the file 
    pFile = fopen( pFileName, "w" );
    fprintf( pFile, "# BLIF file written by procedure Nwk_ManDumpBlif()\n" );
//    fprintf( pFile, "# http://www.eecs.berkeley.edu/~alanmi/abc/\n" );
    fprintf( pFile, ".model %s\n", pNtk->pName );
    // write PIs
    fprintf( pFile, ".inputs" );
    Nwk_ManForEachCi( pNtk, pObj, i )
        if ( vPiNames )
            fprintf( pFile, " %s", (char*)Vec_PtrEntry(vPiNames, i) );
        else
            fprintf( pFile, " n%0*d", nDigits, pObj->Id );
    fprintf( pFile, "\n" );
    // write POs
    fprintf( pFile, ".outputs" );
    Nwk_ManForEachCo( pNtk, pObj, i )
        if ( vPoNames )
            fprintf( pFile, " %s", (char*)Vec_PtrEntry(vPoNames, i) );
        else
            fprintf( pFile, " n%0*d", nDigits, pObj->Id );
    fprintf( pFile, "\n" );
    // write nodes
    pMem = Aig_MmFlexStart();
    vTruth = Vec_IntAlloc( 1 << 16 );
    vCover = Vec_IntAlloc( 1 << 16 );
    vNodes = Nwk_ManDfs( pNtk );
    Vec_PtrForEachEntry( Nwk_Obj_t *, vNodes, pObj, i )
    {
        if ( !Nwk_ObjIsNode(pObj) )
            continue;
        // derive SOP for the AIG
        pTruth = Hop_ManConvertAigToTruth( pNtk->pManHop, Hop_Regular(pObj->pFunc), Nwk_ObjFaninNum(pObj), vTruth, 0 );
        if ( Hop_IsComplement(pObj->pFunc) )
            Kit_TruthNot( pTruth, pTruth, Nwk_ObjFaninNum(pObj) );
        pSop = Kit_PlaFromTruth( pMem, pTruth, Nwk_ObjFaninNum(pObj), vCover );
        // write the node
        fprintf( pFile, ".names" );
        if ( !Kit_TruthIsConst0(pTruth, Nwk_ObjFaninNum(pObj)) && !Kit_TruthIsConst1(pTruth, Nwk_ObjFaninNum(pObj)) )
        {
            Nwk_ObjForEachFanin( pObj, pFanin, k )
                if ( vPiNames && Nwk_ObjIsPi(pFanin) )
                    fprintf( pFile, " %s", (char*)Vec_PtrEntry(vPiNames, Nwk_ObjPioNum(pFanin)) );
                else
                    fprintf( pFile, " n%0*d", nDigits, pFanin->Id );
        }
        fprintf( pFile, " n%0*d\n", nDigits, pObj->Id );
        // write the function
        fprintf( pFile, "%s", pSop );
    }
    Vec_IntFree( vCover );
    Vec_IntFree( vTruth );
    Vec_PtrFree( vNodes );
    Aig_MmFlexStop( pMem, 0 );
    // write POs
    Nwk_ManForEachCo( pNtk, pObj, i )
    {
        fprintf( pFile, ".names" );
        if ( vPiNames && Nwk_ObjIsPi(Nwk_ObjFanin0(pObj)) )
            fprintf( pFile, " %s", (char*)Vec_PtrEntry(vPiNames, Nwk_ObjPioNum(Nwk_ObjFanin0(pObj))) );
        else
            fprintf( pFile, " n%0*d", nDigits, Nwk_ObjFanin0(pObj)->Id );
        if ( vPoNames )
            fprintf( pFile, " %s\n", (char*)Vec_PtrEntry(vPoNames, Nwk_ObjPioNum(pObj)) );
        else
            fprintf( pFile, " n%0*d\n", nDigits, pObj->Id );
        fprintf( pFile, "%d 1\n", !pObj->fInvert );
    }
    fprintf( pFile, ".end\n\n" );
    fclose( pFile );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Nwk_ManFree()

ABC_DLL void Nwk_ManFree ( Nwk_Man_t * p )

extern

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

Synopsis [Deallocates the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 71 of file nwkMan.c.

{
//    printf( "The number of realloced nodes = %d.\n", p->nRealloced );
    if ( p->pName )    ABC_FREE( p->pName );
    if ( p->pSpec )    ABC_FREE( p->pSpec );
    if ( p->vCis )     Vec_PtrFree( p->vCis );
    if ( p->vCos )     Vec_PtrFree( p->vCos );
    if ( p->vObjs )    Vec_PtrFree( p->vObjs );
    if ( p->vTemp )    Vec_PtrFree( p->vTemp );
    if ( p->pManTime ) Tim_ManStop( p->pManTime );
    if ( p->pMemObjs ) Aig_MmFlexStop( p->pMemObjs, 0 );
    if ( p->pManHop )  Hop_ManStop( p->pManHop );
    ABC_FREE( p );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Nwk_ManLutMerge()

ABC_DLL Vec_Int_t * Nwk_ManLutMerge ( Nwk_Man_t * pNtk, void * pParsInit )

extern

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

Synopsis [Performs LUT merging with parameters.]

Description []

SideEffects []

SeeAlso []

Definition at line 970 of file nwkMerge.c.

{
    Nwk_LMPars_t * pPars = (Nwk_LMPars_t *)pParsInit;
    Nwk_Grf_t * p;
    Vec_Int_t * vResult;
    Vec_Ptr_t * vStart, * vNext, * vCands1, * vCands2;
    Nwk_Obj_t * pLut, * pCand;
    int i, k, nVertsMax, nCands;
    abctime clk = Abc_Clock();
    // count the number of vertices
    nVertsMax = 0;
    Nwk_ManForEachNode( pNtk, pLut, i )
        nVertsMax += (int)(Nwk_ObjFaninNum(pLut) <= pPars->nMaxLutSize);
    p = Nwk_ManGraphAlloc( nVertsMax );
    // create graph
    vStart  = Vec_PtrAlloc( 1000 );
    vNext   = Vec_PtrAlloc( 1000 );
    vCands1 = Vec_PtrAlloc( 1000 );
    vCands2 = Vec_PtrAlloc( 1000 );
    nCands  = 0;
    Nwk_ManForEachNode( pNtk, pLut, i )
    {
        if ( Nwk_ObjFaninNum(pLut) > pPars->nMaxLutSize )
            continue;
        Nwk_ManCollectOverlapCands( pLut, vCands1, pPars );
        if ( pPars->fUseDiffSupp )
            Nwk_ManCollectNonOverlapCands( pLut, vStart, vNext, vCands2, pPars );
        if ( Vec_PtrSize(vCands1) == 0 && Vec_PtrSize(vCands2) == 0 )
            continue;
        nCands += Vec_PtrSize(vCands1) + Vec_PtrSize(vCands2);
        // save candidates
        Vec_PtrForEachEntry( Nwk_Obj_t *, vCands1, pCand, k )
            Nwk_ManGraphHashEdge( p, Nwk_ObjId(pLut), Nwk_ObjId(pCand) );
        Vec_PtrForEachEntry( Nwk_Obj_t *, vCands2, pCand, k )
            Nwk_ManGraphHashEdge( p, Nwk_ObjId(pLut), Nwk_ObjId(pCand) );
        // print statistics about this node
        if ( pPars->fVeryVerbose )
        printf( "Node %6d : Fanins = %d. Fanouts = %3d.  Cand1 = %3d. Cand2 = %3d.\n",
            Nwk_ObjId(pLut), Nwk_ObjFaninNum(pLut), Nwk_ObjFaninNum(pLut), 
            Vec_PtrSize(vCands1), Vec_PtrSize(vCands2) );
    }
    Vec_PtrFree( vStart );
    Vec_PtrFree( vNext );
    Vec_PtrFree( vCands1 );
    Vec_PtrFree( vCands2 );
    if ( pPars->fVerbose )
    {
        printf( "Mergable LUTs = %6d. Total cands = %6d. ", p->nVertsMax, nCands );
        ABC_PRT( "Deriving graph", Abc_Clock() - clk );
    }
    // solve the graph problem
    clk = Abc_Clock();
    Nwk_ManGraphSolve( p );
    if ( pPars->fVerbose )
    {
        printf( "GRAPH: Nodes = %6d. Edges = %6d.  Pairs = %6d.  ", 
            p->nVerts, p->nEdges, Vec_IntSize(p->vPairs)/2 );
        ABC_PRT( "Solving", Abc_Clock() - clk );
        Nwk_ManGraphReportMemoryUsage( p );
    }
    vResult = p->vPairs; p->vPairs = NULL;
/*
    for ( i = 0; i < vResult->nSize; i += 2 )
        printf( "(%d,%d) ", vResult->pArray[i], vResult->pArray[i+1] );
    printf( "\n" );
*/
    Nwk_ManGraphFree( p );
    return vResult;
}

Here is the call graph for this function:

Nwk_ManPrintFanioNew()

ABC_DLL void Nwk_ManPrintFanioNew ( Nwk_Man_t * pNtk )

extern

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

Synopsis [Prints the distribution of fanins/fanouts in the network.]

Description []

SideEffects []

SeeAlso []

Definition at line 357 of file nwkUtil.c.

{
    char Buffer[100];
    Nwk_Obj_t * pNode;
    Vec_Int_t * vFanins, * vFanouts;
    int nFanins, nFanouts, nFaninsMax, nFanoutsMax, nFaninsAll, nFanoutsAll;
    int i, k, nSizeMax;
 
    // determine the largest fanin and fanout
    nFaninsMax = nFanoutsMax = 0;
    nFaninsAll = nFanoutsAll = 0;
    Nwk_ManForEachNode( pNtk, pNode, i )
    {
        nFanins  = Nwk_ObjFaninNum(pNode);
        nFanouts = Nwk_ObjFanoutNum(pNode);
        nFaninsAll  += nFanins;
        nFanoutsAll += nFanouts;
        nFaninsMax   = Abc_MaxInt( nFaninsMax, nFanins );
        nFanoutsMax  = Abc_MaxInt( nFanoutsMax, nFanouts );
    }
 
    // allocate storage for fanin/fanout numbers
    nSizeMax = Abc_MaxInt( 10 * (Abc_Base10Log(nFaninsMax) + 1), 10 * (Abc_Base10Log(nFanoutsMax) + 1) );
    vFanins  = Vec_IntStart( nSizeMax );
    vFanouts = Vec_IntStart( nSizeMax );
 
    // count the number of fanins and fanouts
    Nwk_ManForEachNode( pNtk, pNode, i )
    {
        nFanins  = Nwk_ObjFaninNum(pNode);
        nFanouts = Nwk_ObjFanoutNum(pNode);
//        nFanouts = Nwk_NodeMffcSize(pNode);
 
        if ( nFanins < 10 )
            Vec_IntAddToEntry( vFanins, nFanins, 1 );
        else if ( nFanins < 100 )
            Vec_IntAddToEntry( vFanins, 10 + nFanins/10, 1 );
        else if ( nFanins < 1000 )
            Vec_IntAddToEntry( vFanins, 20 + nFanins/100, 1 );
        else if ( nFanins < 10000 )
            Vec_IntAddToEntry( vFanins, 30 + nFanins/1000, 1 );
        else if ( nFanins < 100000 )
            Vec_IntAddToEntry( vFanins, 40 + nFanins/10000, 1 );
        else if ( nFanins < 1000000 )
            Vec_IntAddToEntry( vFanins, 50 + nFanins/100000, 1 );
        else if ( nFanins < 10000000 )
            Vec_IntAddToEntry( vFanins, 60 + nFanins/1000000, 1 );
 
        if ( nFanouts < 10 )
            Vec_IntAddToEntry( vFanouts, nFanouts, 1 );
        else if ( nFanouts < 100 )
            Vec_IntAddToEntry( vFanouts, 10 + nFanouts/10, 1 );
        else if ( nFanouts < 1000 )
            Vec_IntAddToEntry( vFanouts, 20 + nFanouts/100, 1 );
        else if ( nFanouts < 10000 )
            Vec_IntAddToEntry( vFanouts, 30 + nFanouts/1000, 1 );
        else if ( nFanouts < 100000 )
            Vec_IntAddToEntry( vFanouts, 40 + nFanouts/10000, 1 );
        else if ( nFanouts < 1000000 )
            Vec_IntAddToEntry( vFanouts, 50 + nFanouts/100000, 1 );
        else if ( nFanouts < 10000000 )
            Vec_IntAddToEntry( vFanouts, 60 + nFanouts/1000000, 1 );
    }
 
    printf( "The distribution of fanins and fanouts in the network:\n" );
    printf( "         Number   Nodes with fanin  Nodes with fanout\n" );
    for ( k = 0; k < nSizeMax; k++ )
    {
        if ( vFanins->pArray[k] == 0 && vFanouts->pArray[k] == 0 )
            continue;
        if ( k < 10 )
            printf( "%15d : ", k );
        else
        {
            sprintf( Buffer, "%d - %d", (int)pow((double)10, k/10) * (k%10), (int)pow((double)10, k/10) * (k%10+1) - 1 ); 
            printf( "%15s : ", Buffer );
        }
        if ( vFanins->pArray[k] == 0 )
            printf( "              " );
        else
            printf( "%12d  ", vFanins->pArray[k] );
        printf( "    " );
        if ( vFanouts->pArray[k] == 0 )
            printf( "              " );
        else
            printf( "%12d  ", vFanouts->pArray[k] );
        printf( "\n" );
    }
    Vec_IntFree( vFanins );
    Vec_IntFree( vFanouts );
 
    printf( "Fanins: Max = %d. Ave = %.2f.  Fanouts: Max = %d. Ave =  %.2f.\n", 
        nFaninsMax,  1.0*nFaninsAll/Nwk_ManNodeNum(pNtk), 
        nFanoutsMax, 1.0*nFanoutsAll/Nwk_ManNodeNum(pNtk)  );
}

Here is the call graph for this function:

Nwk_ManPrintStats()

ABC_DLL void Nwk_ManPrintStats ( Nwk_Man_t * pNtk, If_LibLut_t * pLutLib, int fSaveBest, int fDumpResult, int fPower, Ntl_Man_t * pNtl )

extern

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

Synopsis [Prints stats of the manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 234 of file nwkMan.c.

{
//    extern int Ntl_ManLatchNum( Ntl_Man_t * p );
//    extern void Ntl_ManWriteBlifLogic( Nwk_Man_t * pNtk, void * pNtl, char * pFileName );
    if ( fSaveBest )
        Nwk_ManCompareAndSaveBest( pNtk, pNtl );
    if ( fDumpResult )
    {
        char Buffer[1000] = {0};
        const char * pNameGen = pNtk->pSpec? Nwk_FileNameGeneric( pNtk->pSpec ) : "nameless_";
        sprintf( Buffer, "%s_dump.blif", pNameGen );
//        Ntl_ManWriteBlifLogic( pNtk, pNtl, Buffer );
//        sprintf( Buffer, "%s_dump_map.blif", pNameGen );
//        Nwk_ManDumpBlif( pNtk, Buffer, NULL, NULL );
        if ( pNtk->pSpec ) ABC_FREE( pNameGen );
    }
 
    pNtk->pLutLib = pLutLib;
    printf( "%-15s : ",      pNtk->pName );
    printf( "pi = %5d  ",    Nwk_ManPiNum(pNtk) );
    printf( "po = %5d  ",    Nwk_ManPoNum(pNtk) );
    printf( "ci = %5d  ",    Nwk_ManCiNum(pNtk) );
    printf( "co = %5d  ",    Nwk_ManCoNum(pNtk) );
//    printf( "lat = %5d  ",   Ntl_ManLatchNum(pNtl) );
    printf( "node = %5d  ",  Nwk_ManNodeNum(pNtk) );
    printf( "edge = %5d  ",  Nwk_ManGetTotalFanins(pNtk) );
    printf( "aig = %6d  ",   Nwk_ManGetAigNodeNum(pNtk) );
    printf( "lev = %3d  ",   Nwk_ManLevel(pNtk) );
//    printf( "lev2 = %3d  ",  Nwk_ManLevelBackup(pNtk) );
    printf( "delay = %5.2f  ", Nwk_ManDelayTraceLut(pNtk) );
    if ( fPower )
        printf( "power = %7.2f   ", Nwl_ManComputeTotalSwitching(pNtk) );
    Nwk_ManPrintLutSizes( pNtk, pLutLib );
    printf( "\n" );
//    Nwk_ManDelayTracePrint( pNtk, pLutLib );
    fflush( stdout );
}

Here is the call graph for this function:

Nwk_ManPrintStatsShort()

ABC_DLL void Nwk_ManPrintStatsShort ( Ntl_Man_t * p, Aig_Man_t * pAig, Nwk_Man_t * pNtk )

extern

Nwk_ManSetIfParsDefault()

ABC_DLL void Nwk_ManSetIfParsDefault ( If_Par_t * pPars )

extern

DECLARATIONS ///.

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

FileName [nwkMap.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Logic network representation.]

Synopsis [Interface to technology mapping.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id

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

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Load the network into FPGA manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 46 of file nwkMap.c.

{
//    extern void * Abc_FrameReadLibLut();
    // set defaults
    memset( pPars, 0, sizeof(If_Par_t) );
    // user-controlable paramters
//    pPars->nLutSize    = -1;
    pPars->nLutSize    =  6;
    pPars->nCutsMax    =  8;
    pPars->nFlowIters  =  1;
    pPars->nAreaIters  =  2;
    pPars->DelayTarget = -1;
    pPars->Epsilon     =  (float)0.005;
    pPars->fPreprocess =  1;
    pPars->fArea       =  0;
    pPars->fFancy      =  0;
    pPars->fExpRed     =  1; 
    pPars->fLatchPaths =  0;
    pPars->fEdge       =  1;
    pPars->fPower      =  0;
    pPars->fCutMin     =  0;
    pPars->fVerbose    =  0;
    // internal parameters
    pPars->fTruth      =  0;
    pPars->nLatchesCi  =  0;
    pPars->nLatchesCo  =  0;
    pPars->fLiftLeaves =  0;
//    pPars->pLutLib     =  Abc_FrameReadLibLut();
    pPars->pLutLib     =  NULL;
    pPars->pTimesArr   =  NULL; 
    pPars->pTimesArr   =  NULL;   
    pPars->pFuncCost   =  NULL;   
/*
    if ( pPars->nLutSize == -1 )
    {
        if ( pPars->pLutLib == NULL )
        {
            printf( "The LUT library is not given.\n" );
            return;
        }
        // get LUT size from the library
        pPars->nLutSize = pPars->pLutLib->LutMax;
    }
*/
}

Here is the call graph for this function:

Nwk_ManSpeedup()

ABC_DLL Aig_Man_t * Nwk_ManSpeedup ( Nwk_Man_t * pNtk, int fUseLutLib, int Percentage, int Degree, int fVerbose, int fVeryVerbose )

extern

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

Synopsis [Adds choices to speed up the network by the given percentage.]

Description []

SideEffects []

SeeAlso []

Definition at line 203 of file nwkSpeedup.c.

{
    Aig_Man_t * pAig, * pTemp;
    Vec_Ptr_t * vTimeCries, * vTimeFanins;
    Nwk_Obj_t * pNode, * pFanin, * pFanin2;
    Aig_Obj_t * pAnd;
    If_LibLut_t * pTempLib = pNtk->pLutLib;
    Tim_Man_t * pTempTim = NULL; 
    float tDelta, tArrival;
    int i, k, k2, Counter, CounterRes, nTimeCris;
    unsigned * puTCEdges;
    // perform delay trace
    if ( !fUseLutLib )
    {
        pNtk->pLutLib = NULL;
        if ( pNtk->pManTime )
        {
            pTempTim = pNtk->pManTime;
            pNtk->pManTime = Tim_ManDup( pTempTim, 1 );
        }
    }
    tArrival = Nwk_ManDelayTraceLut( pNtk );
    tDelta = fUseLutLib ? tArrival*Percentage/100.0 : 1.0;
    if ( fVerbose )
    {
        printf( "Max delay = %.2f. Delta = %.2f. ", tArrival, tDelta );
        printf( "Using %s model. ", fUseLutLib? "LUT library" : "unit-delay" );
        if ( fUseLutLib )
            printf( "Percentage = %d. ", Percentage );
        printf( "\n" );
    }
    // mark the timing critical nodes and edges
    puTCEdges = ABC_ALLOC( unsigned, Nwk_ManObjNumMax(pNtk) );
    memset( puTCEdges, 0, sizeof(unsigned) * Nwk_ManObjNumMax(pNtk) );
    Nwk_ManForEachNode( pNtk, pNode, i )
    {
        if ( Nwk_ObjSlack(pNode) >= tDelta )
            continue;
        puTCEdges[pNode->Id] = Nwk_ManDelayTraceTCEdges( pNtk, pNode, tDelta, fUseLutLib );
    }
    if ( fVerbose )
    {
        Counter = CounterRes = 0;
        Nwk_ManForEachNode( pNtk, pNode, i )
        {
            Nwk_ObjForEachFanin( pNode, pFanin, k )
                if ( !Nwk_ObjIsCi(pFanin) && Nwk_ObjSlack(pFanin) < tDelta )
                    Counter++;
            CounterRes += Aig_WordCountOnes( puTCEdges[pNode->Id] );
        }
        printf( "Edges: Total = %7d. 0-slack = %7d. Critical = %7d. Ratio = %4.2f\n", 
            Nwk_ManGetTotalFanins(pNtk), Counter, CounterRes, Counter? 1.0*CounterRes/Counter : 0.0 );
    }
    // start the resulting network
    pAig = Nwk_ManStrash( pNtk );
    pAig->pEquivs = ABC_ALLOC( Aig_Obj_t *, 3 * Aig_ManObjNumMax(pAig) );
    memset( pAig->pEquivs, 0, sizeof(Aig_Obj_t *) * 3 * Aig_ManObjNumMax(pAig) );
 
    // collect nodes to be used for resynthesis
    Counter = CounterRes = 0;
    vTimeCries = Vec_PtrAlloc( 16 );
    vTimeFanins = Vec_PtrAlloc( 16 );
    Nwk_ManForEachNode( pNtk, pNode, i )
    {
        if ( Nwk_ObjSlack(pNode) >= tDelta )
            continue;
        // count the number of non-PI timing-critical nodes
        nTimeCris = 0;
        Nwk_ObjForEachFanin( pNode, pFanin, k )
            if ( !Nwk_ObjIsCi(pFanin) && (puTCEdges[pNode->Id] & (1<<k)) )
                nTimeCris++;
        if ( !fVeryVerbose && nTimeCris == 0 )
            continue;
        Counter++;
        // count the total number of timing critical second-generation nodes
        Vec_PtrClear( vTimeCries );
        if ( nTimeCris )
        {
            Nwk_ObjForEachFanin( pNode, pFanin, k )
                if ( !Nwk_ObjIsCi(pFanin) && (puTCEdges[pNode->Id] & (1<<k)) )
                    Nwk_ObjForEachFanin( pFanin, pFanin2, k2 )
                        if ( puTCEdges[pFanin->Id] & (1<<k2) )
                            Vec_PtrPushUnique( vTimeCries, pFanin2 );
        }
//        if ( !fVeryVerbose && (Vec_PtrSize(vTimeCries) == 0 || Vec_PtrSize(vTimeCries) > Degree) )
        if ( (Vec_PtrSize(vTimeCries) == 0 || Vec_PtrSize(vTimeCries) > Degree) )
            continue;
        CounterRes++;
        // collect second generation nodes
        Vec_PtrClear( vTimeFanins );
        Nwk_ObjForEachFanin( pNode, pFanin, k )
        {
            if ( Nwk_ObjIsCi(pFanin) )
                Vec_PtrPushUnique( vTimeFanins, pFanin );
            else
                Nwk_ObjForEachFanin( pFanin, pFanin2, k2 )
                    Vec_PtrPushUnique( vTimeFanins, pFanin2 );                    
        }
        // print the results
        if ( fVeryVerbose )
        {
        printf( "%5d Node %5d : %d %2d %2d  ", Counter, pNode->Id, 
            nTimeCris, Vec_PtrSize(vTimeCries), Vec_PtrSize(vTimeFanins) );
        Nwk_ObjForEachFanin( pNode, pFanin, k )
            printf( "%d(%.2f)%s ", pFanin->Id, Nwk_ObjSlack(pFanin), (puTCEdges[pNode->Id] & (1<<k))? "*":"" );
        printf( "\n" );
        }
        // add the node to choices
        if ( Vec_PtrSize(vTimeCries) == 0 || Vec_PtrSize(vTimeCries) > Degree )
            continue;
        // order the fanins in the increasing order of criticalily
        if ( Vec_PtrSize(vTimeCries) > 1 )
        {
            pFanin = (Nwk_Obj_t *)Vec_PtrEntry( vTimeCries, 0 );
            pFanin2 = (Nwk_Obj_t *)Vec_PtrEntry( vTimeCries, 1 );
            if ( Nwk_ObjSlack(pFanin) < Nwk_ObjSlack(pFanin2) )
            {
                Vec_PtrWriteEntry( vTimeCries, 0, pFanin2 );
                Vec_PtrWriteEntry( vTimeCries, 1, pFanin );
            }
        }
        if ( Vec_PtrSize(vTimeCries) > 2 )
        {
            pFanin = (Nwk_Obj_t *)Vec_PtrEntry( vTimeCries, 1 );
            pFanin2 = (Nwk_Obj_t *)Vec_PtrEntry( vTimeCries, 2 );
            if ( Nwk_ObjSlack(pFanin) < Nwk_ObjSlack(pFanin2) )
            {
                Vec_PtrWriteEntry( vTimeCries, 1, pFanin2 );
                Vec_PtrWriteEntry( vTimeCries, 2, pFanin );
            }
            pFanin = (Nwk_Obj_t *)Vec_PtrEntry( vTimeCries, 0 );
            pFanin2 = (Nwk_Obj_t *)Vec_PtrEntry( vTimeCries, 1 );
            if ( Nwk_ObjSlack(pFanin) < Nwk_ObjSlack(pFanin2) )
            {
                Vec_PtrWriteEntry( vTimeCries, 0, pFanin2 );
                Vec_PtrWriteEntry( vTimeCries, 1, pFanin );
            }
        }
        // add choice
        Aig_ManSpeedupNode( pNtk, pAig, pNode, vTimeFanins, vTimeCries );
    }
    Vec_PtrFree( vTimeCries );
    Vec_PtrFree( vTimeFanins );
    ABC_FREE( puTCEdges );
    if ( fVerbose )
        printf( "Nodes: Total = %7d. 0-slack = %7d. Workable = %7d. Ratio = %4.2f\n", 
        Nwk_ManNodeNum(pNtk), Counter, CounterRes, Counter? 1.0*CounterRes/Counter : 0.0 ); 
 
    // remove invalid choice nodes
    Aig_ManForEachNode( pAig, pAnd, i )
        if ( Aig_ObjEquiv(pAig, pAnd) )
        {
            if ( Aig_ObjRefs(Aig_ObjEquiv(pAig, pAnd)) > 0 )
                pAig->pEquivs[pAnd->Id] = NULL;
        }
 
    // put back the library
    if ( !fUseLutLib )
        pNtk->pLutLib = pTempLib;
    if ( pTempTim )
    {
        Tim_ManStop( pNtk->pManTime );
        pNtk->pManTime = pTempTim;
    }
 
    // reconstruct the network
    pAig = Aig_ManDupDfs( pTemp = pAig );
    Aig_ManStop( pTemp );
    // reset levels
    Aig_ManChoiceLevel( pAig );
    return pAig;
}

Here is the call graph for this function:

Nwk_ManStrash()

ABC_DLL Aig_Man_t * Nwk_ManStrash ( Nwk_Man_t * pNtk )

extern

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

Synopsis [Derives AIG from the logic network.]

Description [Assumes topological ordering of nodes.]

SideEffects []

SeeAlso []

Definition at line 99 of file nwkStrash.c.

{
    Vec_Ptr_t * vObjs;
    Aig_Man_t * pMan;
    Aig_Obj_t * pObjNew = NULL;
    Nwk_Obj_t * pObj;
    int i, Level;
    pMan = Aig_ManStart( Nwk_ManGetAigNodeNum(pNtk) );
    pMan->pName = Abc_UtilStrsav( pNtk->pName );
    pMan->pSpec = Abc_UtilStrsav( pNtk->pSpec );
    pMan->pManTime = Tim_ManDup( (Tim_Man_t *)pNtk->pManTime, 1 );
    Tim_ManIncrementTravId( (Tim_Man_t *)pMan->pManTime );
    Nwk_ManForEachObj( pNtk, pObj, i )
        pObj->pCopy = NULL;
//    Nwk_ManForEachObj( pNtk, pObj, i )
    vObjs = Nwk_ManDfs( pNtk );
    Vec_PtrForEachEntry( Nwk_Obj_t *, vObjs, pObj, i )
    {
        if ( Nwk_ObjIsCi(pObj) )
        {
            pObjNew = Aig_ObjCreateCi(pMan);
            Level = Tim_ManGetCiArrival( (Tim_Man_t *)pMan->pManTime, pObj->PioId );
            Aig_ObjSetLevel( pObjNew, Level );
        }
        else if ( Nwk_ObjIsCo(pObj) )
        {
            pObjNew = Aig_ObjCreateCo( pMan, Aig_NotCond((Aig_Obj_t *)Nwk_ObjFanin0(pObj)->pCopy, pObj->fInvert) );
            Level = Aig_ObjLevel( pObjNew );
            Tim_ManSetCoArrival( (Tim_Man_t *)pMan->pManTime, pObj->PioId, (float)Level );
        }
        else if ( Nwk_ObjIsNode(pObj) )
        {
            pObjNew = Nwk_ManStrashNode( pMan, pObj );
        }
        else
            assert( 0 );
        pObj->pCopy = pObjNew;
    }
    Vec_PtrFree( vObjs );
    Aig_ManCleanup( pMan );
    Aig_ManSetRegNum( pMan, 0 );
    return pMan;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Nwk_MappingIf()

ABC_DLL Nwk_Man_t * Nwk_MappingIf ( Aig_Man_t * p, Tim_Man_t * pManTime, If_Par_t * pPars )

extern

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

Synopsis [Interface with the FPGA mapping package.]

Description []

SideEffects []

SeeAlso []

Definition at line 360 of file nwkMap.c.

{
    Nwk_Man_t * pNtk;
    If_Man_t * pIfMan;
    Vec_Ptr_t * vAigToIf;
    // set the arrival times
    pPars->pTimesArr = ABC_ALLOC( float, Aig_ManCiNum(p) );
    memset( pPars->pTimesArr, 0, sizeof(float) * Aig_ManCiNum(p) );
    // translate into the mapper
    vAigToIf = Vec_PtrStart( Aig_ManObjNumMax(p) );
    pIfMan = Nwk_ManToIf( p, pPars, vAigToIf );    
    if ( pIfMan == NULL )
        return NULL;
    pIfMan->pManTim = Tim_ManDup( pManTime, 0 );
    pIfMan->pPars->fCutMin = 0; // is not compatible with deriving result
    if ( !If_ManPerformMapping( pIfMan ) )
    {
        If_ManStop( pIfMan );
        return NULL;
    }
    // transform the result of mapping into the new network
    pNtk = Nwk_ManFromIf( pIfMan, p, vAigToIf );
    if ( pPars->fBidec && pPars->nLutSize <= 8 )
        Nwk_ManBidecResyn( pNtk, 0 );
    If_ManStop( pIfMan );
    Vec_PtrFree( vAigToIf );
    return pNtk;
}

Here is the call graph for this function: