abcOrchestration.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "base/abc/abc.h"
#include "bool/dec/dec.h"
#include "opt/rwr/rwr.h"
#include "bool/kit/kit.h"

Include dependency graph for abcOrchestration.c:

Go to the source code of this file.

Classes
struct	Abc_ManRes_t_
struct	Abc_ManRef_t_

Macros
#define	ABC_RS_DIV1_MAX   150
#define	ABC_RS_DIV2_MAX   500

Typedefs
typedef struct Abc_ManRes_t_	Abc_ManRes_t
typedef struct Abc_ManRef_t_	Abc_ManRef_t

Functions
void	Abc_NodePrintCuts (Abc_Obj_t *pNode)
void	Abc_ManShowCutCone (Abc_Obj_t *pNode, Vec_Ptr_t *vLeaves)
void	Abc_PlaceBegin (Abc_Ntk_t *pNtk)
void	Abc_PlaceEnd (Abc_Ntk_t *pNtk)
void	Abc_PlaceUpdate (Vec_Ptr_t *vAddedCells, Vec_Ptr_t *vUpdatedNets)
int	Dec_GraphUpdateNetwork (Abc_Obj_t *pRoot, Dec_Graph_t *pGraph, int fUpdateLevel, int nGain)
int	Abc_NtkRewrite3 (Abc_Ntk_t *pNtk, Vec_Int_t **pGain_rw, int fUpdateLevel, int fUseZeros, int fVerbose, int fVeryVerbose, int fPlaceEnable)
	FUNCTION DEFINITIONS ///.
word *	Abc_NodeConeTruth_1 (Vec_Ptr_t *vVars, Vec_Ptr_t *vFuncs, int nWordsMax, Abc_Obj_t *pRoot, Vec_Ptr_t *vLeaves, Vec_Ptr_t *vVisited)
int	Abc_NodeConeIsConst0_1 (word *pTruth, int nVars)
int	Abc_NodeConeIsConst1_1 (word *pTruth, int nVars)
Dec_Graph_t *	Abc_NodeRefactor_1 (Abc_ManRef_t *p, Abc_Obj_t *pNode, Vec_Ptr_t *vFanins, int fUpdateLevel, int fUseZeros, int fUseDcs, int fVerbose)
Abc_ManRef_t *	Abc_NtkManRefStart_1 (int nNodeSizeMax, int nConeSizeMax, int fUseDcs, int fVerbose)
void	Abc_NtkManRefStop_1 (Abc_ManRef_t *p)
void	Abc_NtkManRefPrintStats_1 (Abc_ManRef_t *p)
int	Abc_NtkRefactor3 (Abc_Ntk_t *pNtk, Vec_Int_t **pGain_ref, int nNodeSizeMax, int nConeSizeMax, int fUpdateLevel, int fUseZeros, int fUseDcs, int fVerbose)
int	Abc_NtkResubstitute3 (Abc_Ntk_t *pNtk, Vec_Int_t **pGain_res, int nCutMax, int nStepsMax, int nLevelsOdc, int fUpdateLevel, int fVerbose, int fVeryVerbose)
void	Abc_ManResubCollectDivs_rec1 (Abc_Obj_t *pNode, Vec_Ptr_t *vInternal)
Dec_Graph_t *	Abc_ManResubQuit0_1 (Abc_Obj_t *pRoot, Abc_Obj_t *pObj)
Dec_Graph_t *	Abc_ManResubQuit1_1 (Abc_Obj_t *pRoot, Abc_Obj_t *pObj0, Abc_Obj_t *pObj1, int fOrGate)
Dec_Graph_t *	Abc_ManResubQuit21_1 (Abc_Obj_t *pRoot, Abc_Obj_t *pObj0, Abc_Obj_t *pObj1, Abc_Obj_t *pObj2, int fOrGate)
Dec_Graph_t *	Abc_ManResubQuit2_1 (Abc_Obj_t *pRoot, Abc_Obj_t *pObj0, Abc_Obj_t *pObj1, Abc_Obj_t *pObj2, int fOrGate)
Dec_Graph_t *	Abc_ManResubQuit3_1 (Abc_Obj_t *pRoot, Abc_Obj_t *pObj0, Abc_Obj_t *pObj1, Abc_Obj_t *pObj2, Abc_Obj_t *pObj3, int fOrGate)
int	Abc_CutVolumeCheck_rec_1 (Abc_Obj_t *pObj)
void	Abc_CutFactor_rec_1 (Abc_Obj_t *pObj, Vec_Ptr_t *vLeaves)
Vec_Ptr_t *	Abc_CutFactor_1 (Abc_Obj_t *pNode)
int	Abc_NtkOrchSA (Abc_Ntk_t *pNtk, Vec_Int_t **pGain_rwr, Vec_Int_t **pGain_res, Vec_Int_t **pGain_ref, Vec_Int_t **PolicyList, char *DecisionFile, int fUseZeros_rwr, int fUseZeros_ref, int fPlaceEnable, int nCutMax, int nStepsMax, int nLevelsOdc, int fUpdateLevel, int fVerbose, int fVeryVerbose, int nNodeSizeMax, int nConeSizeMax, int fUseDcs)
int	Abc_NtkOrchLocal (Abc_Ntk_t *pNtk, int fUseZeros_rwr, int fUseZeros_ref, int fPlaceEnable, int nCutMax, int nStepsMax, int nLevelsOdc, int fUpdateLevel, int fVerbose, int fVeryVerbose, int nNodeSizeMax, int nConeSizeMax, int fUseDcs)
int	Abc_NtkOchestration (Abc_Ntk_t *pNtk, Vec_Int_t **pGain_rwr, Vec_Int_t **pGain_res, Vec_Int_t **pGain_ref, int sOpsOrder, int fUseZeros_rwr, int fUseZeros_ref, int fPlaceEnable, int nCutMax, int nStepsMax, int nLevelsOdc, int fUpdateLevel, int fVerbose, int fVeryVerbose, int nNodeSizeMax, int nConeSizeMax, int fUseDcs)
int	Abc_NtkOchestration3 (Abc_Ntk_t *pNtk, Vec_Int_t **pGain_rwr, Vec_Int_t **pGain_res, Vec_Int_t **pGain_ref, Vec_Int_t **pOps_num, int fUseZeros, int fUseZeros_rwr, int fUseZeros_ref, int fPlaceEnable, int nCutMax, int nStepsMax, int nLevelsOdc, int fUpdateLevel, int fVerbose, int fVeryVerbose, int nNodeSizeMax, int nConeSizeMax, int fUseDcs)
int	Abc_NtkOchestration2 (Abc_Ntk_t *pNtk, Vec_Int_t **pGain_rwr, Vec_Int_t **pGain_res, Vec_Int_t **pGain_ref, Vec_Int_t **pOps_num, int fUseZeros, int fUseZeros_rwr, int fUseZeros_ref, int fPlaceEnable, int nCutMax, int nStepsMax, int nLevelsOdc, int fUpdateLevel, int fVerbose, int fVeryVerbose, int nNodeSizeMax, int nConeSizeMax, int fUseDcs)
int	Abc_NtkOrchGNN (Abc_Ntk_t *pNtk, char *edgelistFile, char *featFile, int fUseZeros, int fUseZeros_rwr, int fUseZeros_ref, int fPlaceEnable, int nCutMax, int nStepsMax, int nLevelsOdc, int fUpdateLevel, int fVerbose, int fVeryVerbose, int nNodeSizeMax, int nConeSizeMax, int fUseDcs)
int	Abc_NtkOrchRand (Abc_Ntk_t *pNtk, Vec_Int_t **pGain_rwr, Vec_Int_t **pGain_res, Vec_Int_t **pGain_ref, Vec_Int_t **DecisionMask, char *DecisionFile, int Rand_Seed, int fUseZeros_rwr, int fUseZeros_ref, int fPlaceEnable, int nCutMax, int nStepsMax, int nLevelsOdc, int fUpdateLevel, int fVerbose, int fVeryVerbose, int nNodeSizeMax, int nConeSizeMax, int fUseDcs)

Variables
abctime	s_ResubTime

Macro Definition Documentation

ABC_RS_DIV1_MAX

#define ABC_RS_DIV1_MAX   150

Definition at line 44 of file abcOrchestration.c.

ABC_RS_DIV2_MAX

#define ABC_RS_DIV2_MAX   500

Definition at line 45 of file abcOrchestration.c.

Typedef Documentation

Abc_ManRef_t

typedef struct Abc_ManRef_t_ Abc_ManRef_t

Definition at line 135 of file abcOrchestration.c.

Abc_ManRes_t

typedef struct Abc_ManRes_t_ Abc_ManRes_t

Definition at line 47 of file abcOrchestration.c.

Function Documentation

Abc_CutFactor_1()

Vec_Ptr_t * Abc_CutFactor_1

(

Abc_Obj_t *

pNode

)

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

Synopsis [Computes the factor cut of the node.]

Description [Factor-cut is the cut at a node in terms of factor-nodes. Factor-nodes are roots of the node trees (MUXes/EXORs are counted as single nodes). Factor-cut is unique for the given node.]

SideEffects []

SeeAlso []

Definition at line 2537 of file abcOrchestration.c.

{
    Vec_Ptr_t * vLeaves;
    Abc_Obj_t * pObj;
    int i;
    assert( !Abc_ObjIsCi(pNode) );
    vLeaves  = Vec_PtrAlloc( 10 );
    Abc_CutFactor_rec_1( Abc_ObjFanin0(pNode), vLeaves );
    Abc_CutFactor_rec_1( Abc_ObjFanin1(pNode), vLeaves );
    Vec_PtrForEachEntry( Abc_Obj_t *, vLeaves, pObj, i )
        pObj->fMarkA = 0;
    return vLeaves;
}

Here is the call graph for this function:

Abc_CutFactor_rec_1()

void Abc_CutFactor_rec_1	(	Abc_Obj_t *	pObj,
		Vec_Ptr_t *	vLeaves )

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

Synopsis [Computes the factor cut of the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 2508 of file abcOrchestration.c.

{
    if ( pObj->fMarkA )
        return;
    if ( Abc_ObjIsCi(pObj) || (Abc_ObjFanoutNum(pObj) > 1 && !Abc_NodeIsMuxControlType(pObj)) )
    {
        Vec_PtrPush( vLeaves, pObj );
        pObj->fMarkA = 1;
        return;
    }
    Abc_CutFactor_rec_1( Abc_ObjFanin0(pObj), vLeaves );
    Abc_CutFactor_rec_1( Abc_ObjFanin1(pObj), vLeaves );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_CutVolumeCheck_rec_1()

int Abc_CutVolumeCheck_rec_1

(

Abc_Obj_t *

pObj

)

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

Synopsis [Computes the volume and checks if the cut is feasible.]

Description []

SideEffects []

SeeAlso []

Definition at line 2460 of file abcOrchestration.c.

{
    // quit if the node is visited (or if it is a leaf)
    if ( Abc_NodeIsTravIdCurrent(pObj) )
        return 0;
    Abc_NodeSetTravIdCurrent(pObj);
    // report the error
    if ( Abc_ObjIsCi(pObj) )
        printf( "Abc_CutVolumeCheck() ERROR: The set of nodes is not a cut!\n" );
    // count the number of nodes in the leaves
    return 1 + Abc_CutVolumeCheck_rec_1( Abc_ObjFanin0(pObj) ) +
        Abc_CutVolumeCheck_rec_1( Abc_ObjFanin1(pObj) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_ManResubCollectDivs_rec1()

void Abc_ManResubCollectDivs_rec1	(	Abc_Obj_t *	pNode,
		Vec_Ptr_t *	vInternal )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 866 of file abcOrchestration.c.

{
    // skip visited nodes
    if ( Abc_NodeIsTravIdCurrent(pNode) )
        return;
    Abc_NodeSetTravIdCurrent(pNode);
    // collect the fanins
    Abc_ManResubCollectDivs_rec1( Abc_ObjFanin0(pNode), vInternal );
    Abc_ManResubCollectDivs_rec1( Abc_ObjFanin1(pNode), vInternal );
    // collect the internal node
    if ( pNode->fMarkA == 0 ) 
        Vec_PtrPush( vInternal, pNode );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_ManResubQuit0_1()

Dec_Graph_t * Abc_ManResubQuit0_1	(	Abc_Obj_t *	pRoot,
		Abc_Obj_t *	pObj )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1085 of file abcOrchestration.c.

{
    Dec_Graph_t * pGraph;
    Dec_Edge_t eRoot;
    pGraph = Dec_GraphCreate( 1 );
    Dec_GraphNode( pGraph, 0 )->pFunc = pObj;
    eRoot = Dec_EdgeCreate( 0, pObj->fPhase );
    Dec_GraphSetRoot( pGraph, eRoot );
    if ( pRoot->fPhase )
        Dec_GraphComplement( pGraph );
    return pGraph;
}

Abc_ManResubQuit1_1()

Dec_Graph_t * Abc_ManResubQuit1_1	(	Abc_Obj_t *	pRoot,
		Abc_Obj_t *	pObj0,
		Abc_Obj_t *	pObj1,
		int	fOrGate )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1110 of file abcOrchestration.c.

{
    Dec_Graph_t * pGraph;
    Dec_Edge_t eRoot, eNode0, eNode1;
    assert( Abc_ObjRegular(pObj0) != Abc_ObjRegular(pObj1) );
    pGraph = Dec_GraphCreate( 2 );
    Dec_GraphNode( pGraph, 0 )->pFunc = Abc_ObjRegular(pObj0);
    Dec_GraphNode( pGraph, 1 )->pFunc = Abc_ObjRegular(pObj1);
    eNode0 = Dec_EdgeCreate( 0, Abc_ObjRegular(pObj0)->fPhase ^ Abc_ObjIsComplement(pObj0) );
    eNode1 = Dec_EdgeCreate( 1, Abc_ObjRegular(pObj1)->fPhase ^ Abc_ObjIsComplement(pObj1) );
    if ( fOrGate ) 
        eRoot  = Dec_GraphAddNodeOr( pGraph, eNode0, eNode1 );
    else
        eRoot  = Dec_GraphAddNodeAnd( pGraph, eNode0, eNode1 );
    Dec_GraphSetRoot( pGraph, eRoot );
    if ( pRoot->fPhase )
        Dec_GraphComplement( pGraph );
    return pGraph;
}

Abc_ManResubQuit21_1()

Dec_Graph_t * Abc_ManResubQuit21_1	(	Abc_Obj_t *	pRoot,
		Abc_Obj_t *	pObj0,
		Abc_Obj_t *	pObj1,
		Abc_Obj_t *	pObj2,
		int	fOrGate )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1142 of file abcOrchestration.c.

{
    Dec_Graph_t * pGraph;
    Dec_Edge_t eRoot, eNode0, eNode1, eNode2;
    assert( Abc_ObjRegular(pObj0) != Abc_ObjRegular(pObj1) );
    assert( Abc_ObjRegular(pObj0) != Abc_ObjRegular(pObj2) );
    assert( Abc_ObjRegular(pObj1) != Abc_ObjRegular(pObj2) );
    pGraph = Dec_GraphCreate( 3 );
    Dec_GraphNode( pGraph, 0 )->pFunc = Abc_ObjRegular(pObj0);
    Dec_GraphNode( pGraph, 1 )->pFunc = Abc_ObjRegular(pObj1);
    Dec_GraphNode( pGraph, 2 )->pFunc = Abc_ObjRegular(pObj2);
    eNode0 = Dec_EdgeCreate( 0, Abc_ObjRegular(pObj0)->fPhase ^ Abc_ObjIsComplement(pObj0) );
    eNode1 = Dec_EdgeCreate( 1, Abc_ObjRegular(pObj1)->fPhase ^ Abc_ObjIsComplement(pObj1) );
    eNode2 = Dec_EdgeCreate( 2, Abc_ObjRegular(pObj2)->fPhase ^ Abc_ObjIsComplement(pObj2) );
    if ( fOrGate ) 
    {
        eRoot  = Dec_GraphAddNodeOr( pGraph, eNode0, eNode1 );
        eRoot  = Dec_GraphAddNodeOr( pGraph, eNode2, eRoot );
    }
    else
    {
        eRoot  = Dec_GraphAddNodeAnd( pGraph, eNode0, eNode1 );
        eRoot  = Dec_GraphAddNodeAnd( pGraph, eNode2, eRoot );
    }
    Dec_GraphSetRoot( pGraph, eRoot );
    if ( pRoot->fPhase )
        Dec_GraphComplement( pGraph );
    return pGraph;
}

Abc_ManResubQuit2_1()

Dec_Graph_t * Abc_ManResubQuit2_1	(	Abc_Obj_t *	pRoot,
		Abc_Obj_t *	pObj0,
		Abc_Obj_t *	pObj1,
		Abc_Obj_t *	pObj2,
		int	fOrGate )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1185 of file abcOrchestration.c.

{
    Dec_Graph_t * pGraph;
    Dec_Edge_t eRoot, ePrev, eNode0, eNode1, eNode2;
    assert( Abc_ObjRegular(pObj0) != Abc_ObjRegular(pObj1) );
    assert( Abc_ObjRegular(pObj0) != Abc_ObjRegular(pObj2) );
    assert( Abc_ObjRegular(pObj1) != Abc_ObjRegular(pObj2) );
    pGraph = Dec_GraphCreate( 3 );
    Dec_GraphNode( pGraph, 0 )->pFunc = Abc_ObjRegular(pObj0);
    Dec_GraphNode( pGraph, 1 )->pFunc = Abc_ObjRegular(pObj1);
    Dec_GraphNode( pGraph, 2 )->pFunc = Abc_ObjRegular(pObj2);
    eNode0 = Dec_EdgeCreate( 0, Abc_ObjRegular(pObj0)->fPhase ^ Abc_ObjIsComplement(pObj0) );
    if ( Abc_ObjIsComplement(pObj1) && Abc_ObjIsComplement(pObj2) )
    {
        eNode1 = Dec_EdgeCreate( 1, Abc_ObjRegular(pObj1)->fPhase );
        eNode2 = Dec_EdgeCreate( 2, Abc_ObjRegular(pObj2)->fPhase );
        ePrev  = Dec_GraphAddNodeOr( pGraph, eNode1, eNode2 );
    }
    else
    {
        eNode1 = Dec_EdgeCreate( 1, Abc_ObjRegular(pObj1)->fPhase ^ Abc_ObjIsComplement(pObj1) );
        eNode2 = Dec_EdgeCreate( 2, Abc_ObjRegular(pObj2)->fPhase ^ Abc_ObjIsComplement(pObj2) );
        ePrev  = Dec_GraphAddNodeAnd( pGraph, eNode1, eNode2 );
    }
    if ( fOrGate ) 
        eRoot  = Dec_GraphAddNodeOr( pGraph, eNode0, ePrev );
    else
        eRoot  = Dec_GraphAddNodeAnd( pGraph, eNode0, ePrev );
    Dec_GraphSetRoot( pGraph, eRoot );
    if ( pRoot->fPhase )
        Dec_GraphComplement( pGraph );
    return pGraph;
}

Abc_ManResubQuit3_1()

Dec_Graph_t * Abc_ManResubQuit3_1	(	Abc_Obj_t *	pRoot,
		Abc_Obj_t *	pObj0,
		Abc_Obj_t *	pObj1,
		Abc_Obj_t *	pObj2,
		Abc_Obj_t *	pObj3,
		int	fOrGate )

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 1232 of file abcOrchestration.c.

{
    Dec_Graph_t * pGraph;
    Dec_Edge_t eRoot, ePrev0, ePrev1, eNode0, eNode1, eNode2, eNode3;
    assert( Abc_ObjRegular(pObj0) != Abc_ObjRegular(pObj1) );
    assert( Abc_ObjRegular(pObj2) != Abc_ObjRegular(pObj3) );
    pGraph = Dec_GraphCreate( 4 );
    Dec_GraphNode( pGraph, 0 )->pFunc = Abc_ObjRegular(pObj0);
    Dec_GraphNode( pGraph, 1 )->pFunc = Abc_ObjRegular(pObj1);
    Dec_GraphNode( pGraph, 2 )->pFunc = Abc_ObjRegular(pObj2);
    Dec_GraphNode( pGraph, 3 )->pFunc = Abc_ObjRegular(pObj3);
    if ( Abc_ObjIsComplement(pObj0) && Abc_ObjIsComplement(pObj1) )
    {
        eNode0 = Dec_EdgeCreate( 0, Abc_ObjRegular(pObj0)->fPhase );
        eNode1 = Dec_EdgeCreate( 1, Abc_ObjRegular(pObj1)->fPhase );
        ePrev0 = Dec_GraphAddNodeOr( pGraph, eNode0, eNode1 );
        if ( Abc_ObjIsComplement(pObj2) && Abc_ObjIsComplement(pObj3) )
        {
            eNode2 = Dec_EdgeCreate( 2, Abc_ObjRegular(pObj2)->fPhase );
            eNode3 = Dec_EdgeCreate( 3, Abc_ObjRegular(pObj3)->fPhase );
            ePrev1 = Dec_GraphAddNodeOr( pGraph, eNode2, eNode3 );
        }
        else
        {
            eNode2 = Dec_EdgeCreate( 2, Abc_ObjRegular(pObj2)->fPhase ^ Abc_ObjIsComplement(pObj2) );
            eNode3 = Dec_EdgeCreate( 3, Abc_ObjRegular(pObj3)->fPhase ^ Abc_ObjIsComplement(pObj3) );
            ePrev1 = Dec_GraphAddNodeAnd( pGraph, eNode2, eNode3 );
        }
    }
    else
    {
        eNode0 = Dec_EdgeCreate( 0, Abc_ObjRegular(pObj0)->fPhase ^ Abc_ObjIsComplement(pObj0) );
        eNode1 = Dec_EdgeCreate( 1, Abc_ObjRegular(pObj1)->fPhase ^ Abc_ObjIsComplement(pObj1) );
        ePrev0 = Dec_GraphAddNodeAnd( pGraph, eNode0, eNode1 );
        if ( Abc_ObjIsComplement(pObj2) && Abc_ObjIsComplement(pObj3) )
        {
            eNode2 = Dec_EdgeCreate( 2, Abc_ObjRegular(pObj2)->fPhase );
            eNode3 = Dec_EdgeCreate( 3, Abc_ObjRegular(pObj3)->fPhase );
            ePrev1 = Dec_GraphAddNodeOr( pGraph, eNode2, eNode3 );
        }
        else
        {
            eNode2 = Dec_EdgeCreate( 2, Abc_ObjRegular(pObj2)->fPhase ^ Abc_ObjIsComplement(pObj2) );
            eNode3 = Dec_EdgeCreate( 3, Abc_ObjRegular(pObj3)->fPhase ^ Abc_ObjIsComplement(pObj3) );
            ePrev1 = Dec_GraphAddNodeAnd( pGraph, eNode2, eNode3 );
        }
    }
    if ( fOrGate ) 
        eRoot = Dec_GraphAddNodeOr( pGraph, ePrev0, ePrev1 );
    else
        eRoot = Dec_GraphAddNodeAnd( pGraph, ePrev0, ePrev1 );
    Dec_GraphSetRoot( pGraph, eRoot );
    if ( pRoot->fPhase )
        Dec_GraphComplement( pGraph );
    return pGraph;
}

Abc_ManShowCutCone()

void Abc_ManShowCutCone ( Abc_Obj_t * pNode, Vec_Ptr_t * vLeaves )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 347 of file abcRewrite.c.

{
    Abc_Ntk_t * pNtk = pNode->pNtk;
    Abc_Obj_t * pObj;
    Vec_Ptr_t * vDivs;
    int i;
    vDivs = Vec_PtrAlloc( 100 );
    Abc_NtkIncrementTravId( pNtk );
    Vec_PtrForEachEntry( Abc_Obj_t *, vLeaves, pObj, i )
    {
        Abc_NodeSetTravIdCurrent( Abc_ObjRegular(pObj) );
        Vec_PtrPush( vDivs, Abc_ObjRegular(pObj) );
    }
    Abc_ManShowCutCone_rec( pNode, vDivs );
    Abc_ManRewritePrintDivs( vDivs, Vec_PtrSize(vLeaves) );
    Vec_PtrFree( vDivs );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NodeConeIsConst0_1()

int Abc_NodeConeIsConst0_1	(	word *	pTruth,
		int	nVars )

Definition at line 342 of file abcOrchestration.c.

{
    int k, nWords = Abc_Truth6WordNum( nVars );
    for ( k = 0; k < nWords; k++ )
        if ( pTruth[k] )
            return 0;
    return 1;
}

Here is the caller graph for this function:

Abc_NodeConeIsConst1_1()

int Abc_NodeConeIsConst1_1	(	word *	pTruth,
		int	nVars )

Definition at line 350 of file abcOrchestration.c.

{
    int k, nWords = Abc_Truth6WordNum( nVars );
    for ( k = 0; k < nWords; k++ )
        if ( ~pTruth[k] )
            return 0;
    return 1;
}

Here is the caller graph for this function:

Abc_NodeConeTruth_1()

word * Abc_NodeConeTruth_1	(	Vec_Ptr_t *	vVars,
		Vec_Ptr_t *	vFuncs,
		int	nWordsMax,
		Abc_Obj_t *	pRoot,
		Vec_Ptr_t *	vLeaves,
		Vec_Ptr_t *	vVisited )

Definition at line 304 of file abcOrchestration.c.

{   
    Abc_Obj_t * pNode;
    word * pTruth0, * pTruth1, * pTruth = NULL;
    int i, k, nWords = Abc_Truth6WordNum( Vec_PtrSize(vLeaves) );
    Abc_NodeConeCollect( &pRoot, 1, vLeaves, vVisited, 0 );
    Vec_PtrForEachEntry( Abc_Obj_t *, vLeaves, pNode, i )
        pNode->pCopy = (Abc_Obj_t *)Vec_PtrEntry( vVars, i );
    for ( i = Vec_PtrSize(vFuncs); i < Vec_PtrSize(vVisited); i++ )
        Vec_PtrPush( vFuncs, ABC_ALLOC(word, nWordsMax) );
    Vec_PtrForEachEntry( Abc_Obj_t *, vVisited, pNode, i )
    {   
        assert( !Abc_ObjIsPi(pNode) );
        pTruth0 = (word *)Abc_ObjFanin0(pNode)->pCopy;
        pTruth1 = (word *)Abc_ObjFanin1(pNode)->pCopy;
        pTruth  = (word *)Vec_PtrEntry( vFuncs, i );
        if ( Abc_ObjFaninC0(pNode) )
        {   
            if ( Abc_ObjFaninC1(pNode) ) 
                for ( k = 0; k < nWords; k++ )
                    pTruth[k] = ~pTruth0[k] & ~pTruth1[k];
            else
                for ( k = 0; k < nWords; k++ )
                    pTruth[k] = ~pTruth0[k] &  pTruth1[k];
        }
        else
        {
            if ( Abc_ObjFaninC1(pNode) )
                for ( k = 0; k < nWords; k++ )
                    pTruth[k] =  pTruth0[k] & ~pTruth1[k];
            else
                for ( k = 0; k < nWords; k++ )
                    pTruth[k] =  pTruth0[k] &  pTruth1[k];
        }
        pNode->pCopy = (Abc_Obj_t *)pTruth;
    }
    return pTruth;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NodePrintCuts()

void Abc_NodePrintCuts ( Abc_Obj_t * pNode )

extern

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

Synopsis [Prints the cuts at the nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 247 of file abcRewrite.c.

{
    Vec_Ptr_t * vCuts;
    Cut_Cut_t * pCut;
    int k;
 
    printf( "\nNode %s\n", Abc_ObjName(pNode) );
    vCuts = (Vec_Ptr_t *)pNode->pCopy;
    Vec_PtrForEachEntry( Cut_Cut_t *, vCuts, pCut, k )
    {
        Extra_PrintBinary( stdout, (unsigned *)&pCut->uSign, 16 ); 
        printf( "   " );
        Cut_CutPrint( pCut, 0 );   
        printf( "\n" );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NodeRefactor_1()

Dec_Graph_t * Abc_NodeRefactor_1	(	Abc_ManRef_t *	p,
		Abc_Obj_t *	pNode,
		Vec_Ptr_t *	vFanins,
		int	fUpdateLevel,
		int	fUseZeros,
		int	fUseDcs,
		int	fVerbose )

Definition at line 361 of file abcOrchestration.c.

{
    extern int    Dec_GraphToNetworkCount( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, int NodeMax, int LevelMax );
    int fVeryVerbose = 0;
    int nVars = Vec_PtrSize(vFanins);
    int nWordsMax = Abc_Truth6WordNum(p->nNodeSizeMax);
    Dec_Graph_t * pFForm;
    Abc_Obj_t * pFanin;
    word * pTruth;
    abctime clk;
    int i, nNodesSaved, nNodesAdded, Required;
 
    p->nNodesConsidered++;
 
    Required = fUpdateLevel? Abc_ObjRequiredLevel(pNode) : ABC_INFINITY;
clk = Abc_Clock();
    pTruth = Abc_NodeConeTruth_1( p->vVars, p->vFuncs, nWordsMax, pNode, vFanins, p->vVisited );
p->timeTru += Abc_Clock() - clk;
    if ( pTruth == NULL )
        return NULL;
    if ( Abc_NodeConeIsConst0_1(pTruth, nVars) || Abc_NodeConeIsConst1_1(pTruth, nVars) )
    {
        p->nLastGain = Abc_NodeMffcSize( pNode );
        p->nNodesGained += p->nLastGain;
        p->nNodesRefactored++;
        return Abc_NodeConeIsConst0_1(pTruth, nVars) ? Dec_GraphCreateConst0() : Dec_GraphCreateConst1();
    }
clk = Abc_Clock();
    pFForm = (Dec_Graph_t *)Kit_TruthToGraph( (unsigned *)pTruth, nVars, p->vMemory );
p->timeFact += Abc_Clock() - clk;
    Vec_PtrForEachEntry( Abc_Obj_t *, vFanins, pFanin, i )
        pFanin->vFanouts.nSize++;
    Abc_NtkIncrementTravId( pNode->pNtk );
    nNodesSaved = Abc_NodeMffcLabelAig( pNode );
    Vec_PtrForEachEntry( Abc_Obj_t *, vFanins, pFanin, i )
    {
        pFanin->vFanouts.nSize--;
        Dec_GraphNode(pFForm, i)->pFunc = pFanin;
    }
clk = Abc_Clock();
    nNodesAdded = Dec_GraphToNetworkCount( pNode, pFForm, nNodesSaved, Required );
p->timeEval += Abc_Clock() - clk;
    if ( nNodesAdded == -1 || (nNodesAdded == nNodesSaved && !fUseZeros) )
    {
        Dec_GraphFree( pFForm );
        return NULL;
    }
 
    p->nLastGain = nNodesSaved - nNodesAdded;
    p->nNodesGained += p->nLastGain;
    p->nNodesRefactored++;
 
    if ( fVeryVerbose )
    {
        printf( "Node %6s : ",  Abc_ObjName(pNode) );
        printf( "Cone = %2d. ", vFanins->nSize );
        printf( "FF = %2d. ",   1 + Dec_GraphNodeNum(pFForm) );
        printf( "MFFC = %2d. ", nNodesSaved );
        printf( "Add = %2d. ",  nNodesAdded );
        printf( "GAIN = %2d. ", p->nLastGain );
        printf( "\n" );
    }
    return pFForm;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkManRefPrintStats_1()

void Abc_NtkManRefPrintStats_1

(

Abc_ManRef_t *

p

)

Definition at line 454 of file abcOrchestration.c.

{   
    printf( "Refactoring statistics:\n" );
    printf( "Nodes considered  = %8d.\n", p->nNodesConsidered );
    printf( "Nodes refactored  = %8d.\n", p->nNodesRefactored );
    printf( "Gain              = %8d. (%6.2f %%).\n", p->nNodesBeg-p->nNodesEnd, 100.0*(p->nNodesBeg-p->nNodesEnd)/p->nNodesBeg );
    ABC_PRT( "Cuts       ", p->timeCut );
    ABC_PRT( "Resynthesis", p->timeRes );
    ABC_PRT( "    BDD    ", p->timeTru );
    ABC_PRT( "    DCs    ", p->timeDcs );
    ABC_PRT( "    SOP    ", p->timeSop );
    ABC_PRT( "    FF     ", p->timeFact );
    ABC_PRT( "    Eval   ", p->timeEval );
    ABC_PRT( "AIG update ", p->timeNtk );
    ABC_PRT( "TOTAL      ", p->timeTotal );
}

Here is the caller graph for this function:

Abc_NtkManRefStart_1()

Abc_ManRef_t * Abc_NtkManRefStart_1	(	int	nNodeSizeMax,
		int	nConeSizeMax,
		int	fUseDcs,
		int	fVerbose )

Definition at line 428 of file abcOrchestration.c.

{   
    Abc_ManRef_t * p;
    p = ABC_ALLOC( Abc_ManRef_t, 1 );
    memset( p, 0, sizeof(Abc_ManRef_t) );
    p->vCube        = Vec_StrAlloc( 100 );
    p->vVisited     = Vec_PtrAlloc( 100 );
    p->nNodeSizeMax = nNodeSizeMax;
    p->nConeSizeMax = nConeSizeMax;
    p->fVerbose     = fVerbose;
    p->vVars        = Vec_PtrAllocTruthTables( Abc_MaxInt(nNodeSizeMax, 6) );
    p->vFuncs       = Vec_PtrAlloc( 100 );
    p->vMemory      = Vec_IntAlloc( 1 << 16 );
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_NtkManRefStop_1()

void Abc_NtkManRefStop_1

(

Abc_ManRef_t *

p

)

Definition at line 444 of file abcOrchestration.c.

{   
    Vec_PtrFreeFree( p->vFuncs );
    Vec_PtrFree( p->vVars );
    Vec_IntFree( p->vMemory );
    Vec_PtrFree( p->vVisited );
    Vec_StrFree( p->vCube );
    ABC_FREE( p );
}

Here is the caller graph for this function:

Abc_NtkOchestration()

int Abc_NtkOchestration	(	Abc_Ntk_t *	pNtk,
		Vec_Int_t **	pGain_rwr,
		Vec_Int_t **	pGain_res,
		Vec_Int_t **	pGain_ref,
		int	sOpsOrder,
		int	fUseZeros_rwr,
		int	fUseZeros_ref,
		int	fPlaceEnable,
		int	nCutMax,
		int	nStepsMax,
		int	nLevelsOdc,
		int	fUpdateLevel,
		int	fVerbose,
		int	fVeryVerbose,
		int	nNodeSizeMax,
		int	nConeSizeMax,
		int	fUseDcs )

Definition at line 3522 of file abcOrchestration.c.

{
    ProgressBar * pProgress;
    // For resub
    Abc_ManRes_t * pManRes;
    Abc_ManCut_t * pManCutRes;
    Odc_Man_t * pManOdc = NULL;
    Dec_Graph_t * pFFormRes = NULL;
    Vec_Ptr_t * vLeaves;
    // For rewrite
    Cut_Man_t * pManCutRwr;
    Rwr_Man_t * pManRwr;
    Dec_Graph_t * pGraph;
    // For refactor
    Abc_ManRef_t * pManRef;
    Abc_ManCut_t * pManCutRef;
    Dec_Graph_t * pFFormRef;
    Vec_Ptr_t * vFanins;
 
    Abc_Obj_t * pNode;
    FILE *fpt;
    abctime clk, clkStart = Abc_Clock();
    abctime s_ResubTime;
    int i, nNodes, nGain, fCompl;
    int RetValue = 1;
    int ops_rwr = 0;
    int ops_res = 0;
    int ops_ref = 0;
    int ops_null = 0;
    fUseZeros_rwr = 0;
    fUseZeros_ref = 0;
    //clock_t begin= clock();
    assert( Abc_NtkIsStrash(pNtk) );
 
    // cleanup the AIG
    Abc_AigCleanup((Abc_Aig_t *)pNtk->pManFunc);
 
    // start the managers resub
    pManCutRes = Abc_NtkManCutStart( nCutMax, 100000, 100000, 100000 );
    pManRes = Abc_ManResubStart( nCutMax, ABC_RS_DIV1_MAX );
    if ( nLevelsOdc > 0 )
    pManOdc = Abc_NtkDontCareAlloc( nCutMax, nLevelsOdc, fVerbose, fVeryVerbose );
    // start the managers refactor
    pManCutRef = Abc_NtkManCutStart( nNodeSizeMax, nConeSizeMax, 2, 1000 );
    pManRef = Abc_NtkManRefStart_1( nNodeSizeMax, nConeSizeMax, fUseDcs, fVerbose );
    pManRef->vLeaves   = Abc_NtkManCutReadCutLarge( pManCutRef );
    // start the managers rewrite
    pManRwr = Rwr_ManStart( 0 );
    if ( pManRwr == NULL )
        return 0;
 
    // compute the reverse levels if level update is requested
    if ( fUpdateLevel )
        Abc_NtkStartReverseLevels( pNtk, 0 );
 
    // 'Resub only'
    
    if ( Abc_NtkLatchNum(pNtk) ) {
        Abc_NtkForEachLatch(pNtk, pNode, i)
            pNode->pNext = (Abc_Obj_t *)pNode->pData;
    }
    
    // cut manager for rewrite
clk = Abc_Clock();
    pManCutRwr = Abc_NtkStartCutManForRewrite( pNtk );
Rwr_ManAddTimeCuts( pManRwr, Abc_Clock() - clk );
    pNtk->pManCut = pManCutRwr;
 
    if ( fVeryVerbose )
        Rwr_ScoresClean( pManRwr );
 
  // resynthesize each node once
  // resub
    pManRes->nNodesBeg = Abc_NtkNodeNum(pNtk);
  // rewrite
    pManRwr->nNodesBeg = Abc_NtkNodeNum(pNtk);
  // refactor
    pManRef->nNodesBeg = Abc_NtkNodeNum(pNtk);
 
//clock_t resyn_end=clock();
//double resyn_time_spent = (double)(resyn_end-begin)/CLOCKS_PER_SEC;
//printf("time %f\n", resyn_time_spent);
    nNodes = Abc_NtkObjNumMax(pNtk);
    //printf("nNodes: %d\n", nNodes);
    if (pGain_res) *pGain_res = Vec_IntAlloc(1);
    if (pGain_ref) *pGain_ref = Vec_IntAlloc(1);
    if (pGain_rwr) *pGain_rwr = Vec_IntAlloc(1);
 
    pProgress = Extra_ProgressBarStart( stdout, nNodes );
    fpt = fopen("Ochestration_id_ops_nGain.csv", "w");
 
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        //printf("Ochestration id: %d\n", pNode->Id);
        Extra_ProgressBarUpdate( pProgress, i, NULL );
        // skip the constant node
//        if ( Abc_NodeIsConst(pNode) )
//            continue;
        // stop if all nodes have been tried once
        if ( i >= nNodes )
            break;
        // skip persistant nodes
        if ( Abc_NodeIsPersistant(pNode) )
        {
            fprintf(fpt, "%d, %s, %d\n", pNode->Id, "None" , -99);
            Vec_IntPush((*pGain_res), -99);
            Vec_IntPush((*pGain_ref), -99);
            Vec_IntPush((*pGain_rwr), -99);
            continue;
        } 
        // skip the nodes with many fanouts
        if ( Abc_ObjFanoutNum(pNode) > 1000 )
        {
            fprintf(fpt, "%d, %s, %d\n", pNode->Id,"None", -99);
            Vec_IntPush((*pGain_res), -99);
            Vec_IntPush((*pGain_ref), -99);
            Vec_IntPush((*pGain_rwr), -99);
            continue;
        }
clk = Abc_Clock();
/*
      if ( sOpsOrder == 0)
      {
// the order is rwr res ref
        //printf("The graph update order is rwr res ref.\n");
        //printf("fUsezeros:%d \n", fUseZeros_rwr);
       
        nGain = Rwr_NodeRewrite( pManRwr, pManCutRwr, pNode, fUpdateLevel, fUseZeros_rwr, fPlaceEnable );
        //printf("nGain:%d\n", nGain);
        Vec_IntPush( (*pGain_rwr), nGain);
        if ((nGain > 0 || (nGain == 0 && fUseZeros_rwr)))
        {
// Graph update with Rewrite
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
        if ( fCompl ) Dec_GraphComplement( pGraph );
        ops_rwr++;
        continue;
        }
       
        else{
        //printf("Rewrite not work--resub\n");
        //check res
        vLeaves = Abc_NodeFindCut( pManCutRes, pNode, 0 );
//        vLeaves = Abc_CutFactorLarge( pNode, nCutMax );
pManRes->timeCut += Abc_Clock() - clk;
        // get the don't-cares
        if ( pManOdc )
        {
clk = Abc_Clock();
            Abc_NtkDontCareClear( pManOdc );
            Abc_NtkDontCareCompute( pManOdc, pNode, vLeaves, pManRes->pCareSet );
pManRes->timeTruth += Abc_Clock() - clk;
        }
        // evaluate this cut
clk = Abc_Clock();
        pFFormRes = Abc_ManResubEval( pManRes, pNode, vLeaves, nStepsMax, fUpdateLevel, fVerbose );
//        Vec_PtrFree( vLeaves );
//        Abc_ManResubCleanup( pManRes );
pManRes->timeRes += Abc_Clock() - clk;
        // put nGain in Vector
        Vec_IntPush((*pGain_res), pManRes->nLastGain);
        if (pManRes->nLastGain > 0)
        {
// Graph update with Resub
        //printf("Graph Update with Resub\n");
        if ( pFFormRes == NULL )
            continue;
        pManRes->nTotalGain += pManRes->nLastGain;
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pFFormRes, fUpdateLevel, pManRes->nLastGain );
pManRes->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRes );
        ops_res++;
        continue;
        }
        else{
        //check ref
        //printf("Rewrite not work--ref\n");
        vFanins = Abc_NodeFindCut( pManCutRef, pNode, fUseDcs );
pManRef->timeCut += Abc_Clock() - clk;
clk = Abc_Clock();
        pFFormRef = Abc_NodeRefactor_1( pManRef, pNode, vFanins, fUpdateLevel, fUseZeros_ref, fUseDcs, fVerbose );
pManRef->timeRes += Abc_Clock() - clk;
 
        Vec_IntPush((*pGain_ref), pManRef->nLastGain);
        if (pManRef->nLastGain > 0 || (pManRef->nLastGain ==0 && fUseZeros_ref))
        {
// Graph update with Refactor
        //printf("Graph Update with Refactor\n");
        if ( pFFormRef == NULL )
            continue;
clk = Abc_Clock();
        if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef, fUpdateLevel, pManRef->nLastGain ) )
                 {
                     Dec_GraphFree( pFFormRef );
                     RetValue = -1;
                     break;
                 }
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRef );
        ops_ref++;
        continue;
        }
//}
//}
           ops_null++; 
           //continue;         
}
*/
 
 
// Update the graph with pre-defined order!
      if ( sOpsOrder == 0)
      {
// the order is rwr res ref
        //printf("new imp: The graph update order is rwr res ref.\n");
        nGain = Rwr_NodeRewrite( pManRwr, pManCutRwr, pNode, fUpdateLevel, fUseZeros_rwr, fPlaceEnable );
        Vec_IntPush( (*pGain_rwr), nGain);
        if (nGain > 0 || (nGain == 0 && fUseZeros_rwr))
        {
// Graph update with Rewrite
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
        if ( fCompl ) Dec_GraphComplement( pGraph );
        ops_rwr++;
        continue;
        }
        else{
        //printf("Rewrite not work--resub\n");
        //check res
        vLeaves = Abc_NodeFindCut( pManCutRes, pNode, 0 );
//        vLeaves = Abc_CutFactorLarge( pNode, nCutMax );
pManRes->timeCut += Abc_Clock() - clk;
        // get the don't-cares
        if ( pManOdc )
        {
clk = Abc_Clock();
            Abc_NtkDontCareClear( pManOdc );
            Abc_NtkDontCareCompute( pManOdc, pNode, vLeaves, pManRes->pCareSet );
pManRes->timeTruth += Abc_Clock() - clk;
        }
        // evaluate this cut
clk = Abc_Clock();
        pFFormRes = Abc_ManResubEval( pManRes, pNode, vLeaves, nStepsMax, fUpdateLevel, fVerbose );
//        Vec_PtrFree( vLeaves );
//        Abc_ManResubCleanup( pManRes );
pManRes->timeRes += Abc_Clock() - clk;
        // put nGain in Vector
        Vec_IntPush((*pGain_res), pManRes->nLastGain);
        if (pManRes->nLastGain > 0)
        {
// Graph update with Resub
        //printf("Graph Update with Resub\n");
        if ( pFFormRes != NULL ){
            //continue;
        pManRes->nTotalGain += pManRes->nLastGain;
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pFFormRes, fUpdateLevel, pManRes->nLastGain );
pManRes->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRes );
        ops_res++;
        continue;}
        }
        else{
        //check ref
        //printf("Rewrite not work--ref\n");
        vFanins = Abc_NodeFindCut( pManCutRef, pNode, fUseDcs );
pManRef->timeCut += Abc_Clock() - clk;
clk = Abc_Clock();
        pFFormRef = Abc_NodeRefactor_1( pManRef, pNode, vFanins, fUpdateLevel, fUseZeros_ref, fUseDcs, fVerbose );
pManRef->timeRes += Abc_Clock() - clk;
 
        Vec_IntPush((*pGain_ref), pManRef->nLastGain);
        if (pManRef->nLastGain > 0 || (pManRef->nLastGain ==0 && fUseZeros_ref))
        {
// Graph update with Refactor
        //printf("Graph Update with Refactor\n");
        if ( pFFormRef != NULL ){
            //continue;
clk = Abc_Clock();
        
       Dec_GraphUpdateNetwork( pNode, pFFormRef, fUpdateLevel, pManRef->nLastGain);
 
/*
        if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef, fUpdateLevel, pManRef->nLastGain ) )
                 {
                     Dec_GraphFree( pFFormRef );
                     RetValue = -1;
                     break;
                 }
*/
 
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRef );
        ops_ref++;
        continue;}
        }
}
}
           ops_null++; 
           continue;         
}
 
 
      if ( sOpsOrder == 1)
      {
// the order is rwr ref res
        //printf("The graph update order is rwr ref res.\n");
        nGain = Rwr_NodeRewrite( pManRwr, pManCutRwr, pNode, fUpdateLevel, fUseZeros_rwr, fPlaceEnable );
        Vec_IntPush( (*pGain_rwr), nGain);
        if (nGain > 0 || (nGain == 0 && fUseZeros_rwr))
        {
// Graph update with Rewrite
        //printf("Graph Update with Rewrite");
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
        if ( fCompl ) Dec_GraphComplement( pGraph );
        ops_rwr++;
        continue;
        }
        else{
        vFanins = Abc_NodeFindCut( pManCutRef, pNode, fUseDcs );
pManRef->timeCut += Abc_Clock() - clk;
clk = Abc_Clock();
        pFFormRef = Abc_NodeRefactor_1( pManRef, pNode, vFanins, fUpdateLevel, fUseZeros_ref, fUseDcs, fVerbose );
pManRef->timeRes += Abc_Clock() - clk;
        Vec_IntPush((*pGain_ref), pManRef->nLastGain);
        }
        if (pManRef->nLastGain > 0 || (pManRef->nLastGain ==0 && fUseZeros_ref))
        {
// Graph update with Refactor
        //printf("Graph Update with Refactor");
        if ( pFFormRef != NULL ){
            //continue;
clk = Abc_Clock();
        if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef, fUpdateLevel, pManRef->nLastGain ) )
                 {
                     Dec_GraphFree( pFFormRef );
                     RetValue = -1;
                     break;
                 }
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRef );
        ops_ref++;
        continue;}
        }
        else{
        vLeaves = Abc_NodeFindCut( pManCutRes, pNode, 0 );
pManRes->timeCut += Abc_Clock() - clk;
        if ( pManOdc )
        {
clk = Abc_Clock();
            Abc_NtkDontCareClear( pManOdc );
            Abc_NtkDontCareCompute( pManOdc, pNode, vLeaves, pManRes->pCareSet );
pManRes->timeTruth += Abc_Clock() - clk;
        }
clk = Abc_Clock();
        pFFormRes = Abc_ManResubEval( pManRes, pNode, vLeaves, nStepsMax, fUpdateLevel, fVerbose );
pManRes->timeRes += Abc_Clock() - clk;
        Vec_IntPush((*pGain_res), pManRes->nLastGain);
        }
        if (pManRes->nLastGain > 0)
        {
// Graph update with Resub
        //printf("Graph Update with Resub");
        if ( pFFormRes != NULL ){
            //continue;
        pManRes->nTotalGain += pManRes->nLastGain;
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pFFormRes, fUpdateLevel, pManRes->nLastGain );
pManRes->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRes );
        ops_res++;
        continue;}
        }
// No available updats
        //if (! (nGain > 0 || pManRef->nLastGain > 0 || pManRes->nLastGain > 0 || (nGain == 0 && fUseZeros_rwr)))
        else{
        ops_null++;
        continue;
        }
// }
// }
      }
 
      if ( sOpsOrder == 2)
      {
// the order is res rwr ref
        //printf("The graph update order is res rwr ref.\n");
        vLeaves = Abc_NodeFindCut( pManCutRes, pNode, 0 );
pManRes->timeCut += Abc_Clock() - clk;
        if ( pManOdc )
        {
clk = Abc_Clock();
            Abc_NtkDontCareClear( pManOdc );
            Abc_NtkDontCareCompute( pManOdc, pNode, vLeaves, pManRes->pCareSet );
pManRes->timeTruth += Abc_Clock() - clk;
        }
clk = Abc_Clock();
        pFFormRes = Abc_ManResubEval( pManRes, pNode, vLeaves, nStepsMax, fUpdateLevel, fVerbose );
pManRes->timeRes += Abc_Clock() - clk;
  Vec_IntPush((*pGain_res), pManRes->nLastGain);
 
        if (pManRes->nLastGain > 0)
        {
// Graph update with Resub
        //printf("Graph Update with Resub");
        if ( pFFormRes != NULL ){
            //continue;
        pManRes->nTotalGain += pManRes->nLastGain;
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pFFormRes, fUpdateLevel, pManRes->nLastGain );
pManRes->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRes );
        ops_res++;
        continue;}
        }
        else{
        nGain = Rwr_NodeRewrite( pManRwr, pManCutRwr, pNode, fUpdateLevel, fUseZeros_rwr, fPlaceEnable );
        Vec_IntPush( (*pGain_rwr), nGain);
 
        if (nGain > 0 || (nGain == 0 && fUseZeros_rwr))
        {
// Graph update with Rewrite
        //printf("Graph Update with Rewrite");
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
        if ( fCompl ) Dec_GraphComplement( pGraph );
        ops_rwr++;
        continue;
        }
        else{
        vFanins = Abc_NodeFindCut( pManCutRef, pNode, fUseDcs );
pManRef->timeCut += Abc_Clock() - clk;
clk = Abc_Clock();
        pFFormRef = Abc_NodeRefactor_1( pManRef, pNode, vFanins, fUpdateLevel, fUseZeros_ref, fUseDcs, fVerbose );
pManRef->timeRes += Abc_Clock() - clk;
        Vec_IntPush((*pGain_ref), pManRef->nLastGain);
 
        if (pManRef->nLastGain > 0 || (pManRef->nLastGain ==0 && fUseZeros_ref))
        {
// Graph update with Refactor
        //printf("Graph Update with Refactor");
        if ( pFFormRef != NULL ){
            //continue;
clk = Abc_Clock();
        if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef, fUpdateLevel, pManRef->nLastGain ) )
                 {
                     Dec_GraphFree( pFFormRef );
                     RetValue = -1;
                     break;
                 }
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRef );
        ops_ref++;
        continue;}
        }
// No available updates
        //if (! (nGain > 0 || pManRef->nLastGain > 0 || pManRes->nLastGain > 0 || (nGain == 0 && fUseZeros_rwr)))
        else{
        ops_null++;
        continue;
        }
}}
      }
 
      if ( sOpsOrder == 3)
      {
// the order is res ref rwr
        //printf("The graph update order is res ref rwr.\n");
         vLeaves = Abc_NodeFindCut( pManCutRes, pNode, 0 );
pManRes->timeCut += Abc_Clock() - clk;
        if ( pManOdc )
        {
clk = Abc_Clock();
            Abc_NtkDontCareClear( pManOdc );
            Abc_NtkDontCareCompute( pManOdc, pNode, vLeaves, pManRes->pCareSet );
pManRes->timeTruth += Abc_Clock() - clk;
        }
clk = Abc_Clock();
        pFFormRes = Abc_ManResubEval( pManRes, pNode, vLeaves, nStepsMax, fUpdateLevel, fVerbose );
pManRes->timeRes += Abc_Clock() - clk;
        Vec_IntPush((*pGain_res), pManRes->nLastGain);
 
        if (pManRes->nLastGain > 0)
        {
// Graph update with Resub
        //printf("Graph Update with Resub");
        if ( pFFormRes != NULL ){
            //continue;
        pManRes->nTotalGain += pManRes->nLastGain;
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pFFormRes, fUpdateLevel, pManRes->nLastGain );
pManRes->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRes );
        ops_res++;
        continue;}
        }
        else{
        vFanins = Abc_NodeFindCut( pManCutRef, pNode, fUseDcs );
pManRef->timeCut += Abc_Clock() - clk;
clk = Abc_Clock();
        pFFormRef = Abc_NodeRefactor_1( pManRef, pNode, vFanins, fUpdateLevel, fUseZeros_ref, fUseDcs, fVerbose );
pManRef->timeRes += Abc_Clock() - clk;
        Vec_IntPush((*pGain_ref), pManRef->nLastGain);
        //printf("refactor gain: %d\n", pManRef->nLastGain);
        if (pManRef->nLastGain > 0 || (pManRef->nLastGain ==0 && fUseZeros_ref))
        {
// Graph update with Refactor
        //printf("Graph Update with Refactor");
        if ( pFFormRef != NULL ){
            //continue;
clk = Abc_Clock();
        if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef, fUpdateLevel, pManRef->nLastGain ) )
                 {
                     Dec_GraphFree( pFFormRef );
                     RetValue = -1;
                     break;
                 }
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRef );
        ops_ref++;
        continue;}
        }
        else{
        nGain = Rwr_NodeRewrite( pManRwr, pManCutRwr, pNode, fUpdateLevel, fUseZeros_rwr, fPlaceEnable );
        Vec_IntPush( (*pGain_rwr), nGain);
        if (nGain > 0 || (nGain == 0 && fUseZeros_rwr))
        {
// Graph update with Rewrite
        //printf("Graph Update with Rewrite");
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
        if ( fCompl ) Dec_GraphComplement( pGraph );
        ops_rwr++;
        continue;
        }
 
// No available updates
       // if (! (nGain > 0 || pManRef->nLastGain > 0 || pManRes->nLastGain > 0 || (nGain == 0 && fUseZeros_rwr)))
        else{
        ops_null++;
        continue;
        }
}
}
      }
 
      if ( sOpsOrder == 4)
      {
// the order is ref rwr res
        //printf("The graph update order is ref rwr res.\n");
        vFanins = Abc_NodeFindCut( pManCutRef, pNode, fUseDcs );
pManRef->timeCut += Abc_Clock() - clk;
clk = Abc_Clock();
        pFFormRef = Abc_NodeRefactor_1( pManRef, pNode, vFanins, fUpdateLevel, fUseZeros_ref, fUseDcs, fVerbose );
pManRef->timeRes += Abc_Clock() - clk;
        Vec_IntPush((*pGain_ref), pManRef->nLastGain);
 
        if (pManRef->nLastGain > 0 || (pManRef->nLastGain ==0 && fUseZeros_ref))
        {
// Graph update with Refactor
        //printf("Graph Update with Refactor");
        if ( pFFormRef != NULL ){
            //continue;
clk = Abc_Clock();
        if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef, fUpdateLevel, pManRef->nLastGain ) )
                 {
                     Dec_GraphFree( pFFormRef );
                     RetValue = -1;
                     break;
                 }
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRef );
        ops_ref++;
        continue;}
        }
        else{
        nGain = Rwr_NodeRewrite( pManRwr, pManCutRwr, pNode, fUpdateLevel, fUseZeros_rwr, fPlaceEnable );
        Vec_IntPush( (*pGain_rwr), nGain);
 
        if (nGain > 0 || (nGain == 0 && fUseZeros_rwr))
        {
// Graph update with Rewrite
        //printf("Graph Update with Rewrite");
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
        if ( fCompl ) Dec_GraphComplement( pGraph );
        ops_rwr++;
        continue;
        }
        else{
        vLeaves = Abc_NodeFindCut( pManCutRes, pNode, 0 );
pManRes->timeCut += Abc_Clock() - clk;
        if ( pManOdc )
        {
clk = Abc_Clock();
            Abc_NtkDontCareClear( pManOdc );
            Abc_NtkDontCareCompute( pManOdc, pNode, vLeaves, pManRes->pCareSet );
pManRes->timeTruth += Abc_Clock() - clk;
        }
clk = Abc_Clock();
        pFFormRes = Abc_ManResubEval( pManRes, pNode, vLeaves, nStepsMax, fUpdateLevel, fVerbose );
pManRes->timeRes += Abc_Clock() - clk;
        Vec_IntPush((*pGain_res), pManRes->nLastGain);
 
        if (pManRes->nLastGain > 0)
        {
// Graph update with Resub
        //printf("Graph Update with Resub");
        if ( pFFormRes != NULL ){
            //continue;
        pManRes->nTotalGain += pManRes->nLastGain;
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pFFormRes, fUpdateLevel, pManRes->nLastGain );
pManRes->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRes );
        ops_res++;
        continue;}
        }
// No available updates
        //if (! (nGain > 0 || pManRef->nLastGain > 0 || pManRes->nLastGain > 0 || (nGain == 0 && fUseZeros_rwr)))
        else{
        ops_null++;
        continue;
        }
}}
      }
 
      if ( sOpsOrder == 5)
      {
// the order is ref res rwr
        //printf("The graph update order is ref res rwr.\n");
        vFanins = Abc_NodeFindCut( pManCutRef, pNode, fUseDcs );
pManRef->timeCut += Abc_Clock() - clk;
clk = Abc_Clock();
        pFFormRef = Abc_NodeRefactor_1( pManRef, pNode, vFanins, fUpdateLevel, fUseZeros_ref, fUseDcs, fVerbose );
pManRef->timeRes += Abc_Clock() - clk;
        Vec_IntPush((*pGain_ref), pManRef->nLastGain);
 
        if (pManRef->nLastGain > 0 || (pManRef->nLastGain ==0 && fUseZeros_ref))
        {
// Graph update with Refactor
        //printf("Graph Update with Refactor");
        if ( pFFormRef != NULL ){
            //continue;
clk = Abc_Clock();
        if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef, fUpdateLevel, pManRef->nLastGain ) )
                 {
                     Dec_GraphFree( pFFormRef );
                     RetValue = -1;
                     break;
                 }
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRef );
        ops_ref++;
        continue;}
        }
        else{
        vLeaves = Abc_NodeFindCut( pManCutRes, pNode, 0 );
pManRes->timeCut += Abc_Clock() - clk;
        if ( pManOdc )
        {
clk = Abc_Clock();
            Abc_NtkDontCareClear( pManOdc );
            Abc_NtkDontCareCompute( pManOdc, pNode, vLeaves, pManRes->pCareSet );
pManRes->timeTruth += Abc_Clock() - clk;
        }
clk = Abc_Clock();
        pFFormRes = Abc_ManResubEval( pManRes, pNode, vLeaves, nStepsMax, fUpdateLevel, fVerbose );
pManRes->timeRes += Abc_Clock() - clk;
        Vec_IntPush((*pGain_res), pManRes->nLastGain);
 
        if (pManRes->nLastGain > 0)
        {
// Graph update with Resub
        //printf("Graph Update with Resub");
        if ( pFFormRes != NULL ){
            //continue;
        pManRes->nTotalGain += pManRes->nLastGain;
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pFFormRes, fUpdateLevel, pManRes->nLastGain );
pManRes->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRes );
        ops_res++;
        continue;}
        }
        else{
        nGain = Rwr_NodeRewrite( pManRwr, pManCutRwr, pNode, fUpdateLevel, fUseZeros_rwr, fPlaceEnable );
        Vec_IntPush( (*pGain_rwr), nGain);
 
        if (nGain > 0 || (nGain == 0 && fUseZeros_rwr))
        {
// Graph update with Rewrite
        //printf("Graph Update with Rewrite");
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
        if ( fCompl ) Dec_GraphComplement( pGraph );
        ops_rwr++;
        continue;
        }
// No available updates
        //if (! (nGain > 0 || pManRef->nLastGain > 0 || pManRes->nLastGain > 0 || (nGain == 0 && fUseZeros_rwr)))
        else{
        ops_null++;
        continue;
        }
}}
      }
 
    }
 
    fclose(fpt);
    //printf("size of vector %d\n", (**pGain_rwr).nSize);
    //printf("nGain in vector: %d\n", (**pGain_res).pArray[20]);
    //printf("Nodes with rewrite: %d\n", ops_rwr);
    //printf("Nodes with resub: %d\n", ops_res);
    //printf("Nodes with refactor: %d\n", ops_ref);
    //printf("Nodes without updates: %d\n", ops_null);
    Extra_ProgressBarStop( pProgress );
// Rewrite
Rwr_ManAddTimeTotal( pManRwr, Abc_Clock() - clkStart );
    pManRwr->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
// Resub
pManRes->timeTotal = Abc_Clock() - clkStart;
    pManRes->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
// Refactor
pManRef->timeTotal = Abc_Clock() - clkStart;
    pManRef->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
    // print statistics
    if ( fVerbose ){
        Abc_ManResubPrint( pManRes );
        Rwr_ManPrintStats( pManRwr );
        Abc_NtkManRefPrintStats_1( pManRef );
    }
    if ( fVeryVerbose )
        Rwr_ScoresReport( pManRwr );
    // delete the managers
    // resub
    Abc_ManResubStop( pManRes );
    Abc_NtkManCutStop( pManCutRes );
    // rewrite
    Rwr_ManStop( pManRwr );
    Cut_ManStop( pManCutRwr );
    pNtk->pManCut = NULL;
    // refactor
    Abc_NtkManCutStop( pManCutRef );
    Abc_NtkManRefStop_1( pManRef );
 
    if ( pManOdc ) Abc_NtkDontCareFree( pManOdc );
 
    // clean the data field
    Abc_NtkForEachObj( pNtk, pNode, i )
        pNode->pData = NULL;
 
    if ( Abc_NtkLatchNum(pNtk) ) {
        Abc_NtkForEachLatch(pNtk, pNode, i)
            pNode->pData = pNode->pNext, pNode->pNext = NULL;
    }
 
    // put the nodes into the DFS order and reassign their IDs
    Abc_NtkReassignIds( pNtk );
//    Abc_AigCheckFaninOrder( pNtk->pManFunc );
 
    // fix the levels
    if ( fUpdateLevel )
        Abc_NtkStopReverseLevels( pNtk );
    else
        Abc_NtkLevel( pNtk );
    // check
    if ( !Abc_NtkCheck( pNtk ) )
    {
        printf( "Abc_NtkOchestraction: The network check has failed.\n" );
        return 0;
    }
s_ResubTime = Abc_Clock() - clkStart;
//clock_t end=clock();
//double time_spent = (double)(end-begin)/CLOCKS_PER_SEC;
//printf("time %f\n", time_spent);
    return 1;
}

Here is the call graph for this function:

Abc_NtkOchestration2()

int Abc_NtkOchestration2	(	Abc_Ntk_t *	pNtk,
		Vec_Int_t **	pGain_rwr,
		Vec_Int_t **	pGain_res,
		Vec_Int_t **	pGain_ref,
		Vec_Int_t **	pOps_num,
		int	fUseZeros,
		int	fUseZeros_rwr,
		int	fUseZeros_ref,
		int	fPlaceEnable,
		int	nCutMax,
		int	nStepsMax,
		int	nLevelsOdc,
		int	fUpdateLevel,
		int	fVerbose,
		int	fVeryVerbose,
		int	nNodeSizeMax,
		int	nConeSizeMax,
		int	fUseDcs )

Definition at line 4717 of file abcOrchestration.c.

{
    ProgressBar * pProgress;
    // For resub
    Abc_ManRes_t * pManRes;
    Abc_ManCut_t * pManCutRes;
    Odc_Man_t * pManOdc = NULL;
    Dec_Graph_t * pFFormRes;
    Dec_Graph_t * pFFormRef_zeros;
    Vec_Ptr_t * vLeaves;
    // For rewrite
    Cut_Man_t * pManCutRwr;
    Rwr_Man_t * pManRwr;
    Dec_Graph_t * pGraph;
    // For refactor
    Abc_ManRef_t * pManRef;
    Abc_ManCut_t * pManCutRef;
    Dec_Graph_t * pFFormRef;
    Vec_Ptr_t * vFanins;
 
    Abc_Obj_t * pNode;
    FILE *fpt;
    abctime clk, clkStart = Abc_Clock();
    abctime s_ResubTime;
    int i, nNodes, nGain, nGain_zeros, fCompl, RetValue = 1;
    int ops_rwr = 0;
    int ops_res = 0;
    int ops_ref = 0;
    int ops_null = 0;
    int rwr_ok = 0;
    int res_ok = 0;
    int ref_ok = 0;
    int decisionOps = 0;
    assert( Abc_NtkIsStrash(pNtk) );
 
    // cleanup the AIG
    Abc_AigCleanup((Abc_Aig_t *)pNtk->pManFunc);
 
    // start the managers resub
    pManCutRes = Abc_NtkManCutStart( nCutMax, 100000, 100000, 100000 );
    pManRes = Abc_ManResubStart( nCutMax, ABC_RS_DIV1_MAX );
    if ( nLevelsOdc > 0 )
    pManOdc = Abc_NtkDontCareAlloc( nCutMax, nLevelsOdc, fVerbose, fVeryVerbose );
    // start the managers refactor
    pManCutRef = Abc_NtkManCutStart( nNodeSizeMax, nConeSizeMax, 2, 1000 );
    pManRef = Abc_NtkManRefStart_1( nNodeSizeMax, nConeSizeMax, fUseDcs, fVerbose );
    pManRef->vLeaves   = Abc_NtkManCutReadCutLarge( pManCutRef );
    // start the managers rewrite
    pManRwr = Rwr_ManStart( 0 );
    if ( pManRwr == NULL )
        return 0;
 
    // compute the reverse levels if level update is requested
    if ( fUpdateLevel )
        Abc_NtkStartReverseLevels( pNtk, 0 );
 
    // 'Resub only'
    if ( Abc_NtkLatchNum(pNtk) ) {
        Abc_NtkForEachLatch(pNtk, pNode, i)
            pNode->pNext = (Abc_Obj_t *)pNode->pData;
    }
    // cut manager for rewrite
clk = Abc_Clock();
    pManCutRwr = Abc_NtkStartCutManForRewrite( pNtk );
Rwr_ManAddTimeCuts( pManRwr, Abc_Clock() - clk );
    pNtk->pManCut = pManCutRwr;
 
    if ( fVeryVerbose )
        Rwr_ScoresClean( pManRwr );
 
  // resynthesize each node once
  // resub
    pManRes->nNodesBeg = Abc_NtkNodeNum(pNtk);
  // rewrite
    pManRwr->nNodesBeg = Abc_NtkNodeNum(pNtk);
  // refactor
    pManRef->nNodesBeg = Abc_NtkNodeNum(pNtk);
 
    nNodes = Abc_NtkObjNumMax(pNtk);
    //printf("nNodes: %d\n", nNodes);
    if (pGain_res) *pGain_res = Vec_IntAlloc(1);
    if (pGain_ref) *pGain_ref = Vec_IntAlloc(1);
    if (pGain_rwr) *pGain_rwr = Vec_IntAlloc(1);
 
    pProgress = Extra_ProgressBarStart( stdout, nNodes );
    fpt = fopen("Ochestration_id_ops_nGain.csv", "w");
 
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
    //printf("Nodes ID: %d\n", pNode->Id);
    rwr_ok = 0;
    ref_ok = 0;
    res_ok = 0;
    if (pOps_num) *pOps_num = Vec_IntAlloc(1);
        //printf("Ochestration id: %d\n", pNode->Id);
        Extra_ProgressBarUpdate( pProgress, i, NULL );
        // skip the constant node
//        if ( Abc_NodeIsConst(pNode) )
//            continue;
        // skip persistant nodes
        if ( Abc_NodeIsPersistant(pNode) )
        {
            fprintf(fpt, "%d, %d, %d, %d, %d\n", pNode->Id, 0, 0, 0, 0);
            Vec_IntPush((*pGain_res), -99);
            Vec_IntPush((*pGain_ref), -99);
            Vec_IntPush((*pGain_rwr), -99);
            continue;
        } 
        // skip the nodes with many fanouts
        if ( Abc_ObjFanoutNum(pNode) > 1000 )
        {
            fprintf(fpt, "%d, %d, %d, %d, %d\n", pNode->Id, 0, 0, 0, 0);
            Vec_IntPush((*pGain_res), -99);
            Vec_IntPush((*pGain_ref), -99);
            Vec_IntPush((*pGain_rwr), -99);
            continue;
        }
        // stop if all nodes have been tried once
        if ( i >= nNodes )
            break;
clk = Abc_Clock();
 
//Refactor
        vFanins = Abc_NodeFindCut( pManCutRef, pNode, fUseDcs );
pManRef->timeCut += Abc_Clock() - clk;
clk = Abc_Clock();
        pFFormRef = Abc_NodeRefactor_1( pManRef, pNode, vFanins, fUpdateLevel, fUseZeros, fUseDcs, fVerbose );
        pFFormRef_zeros = Abc_NodeRefactor_1( pManRef, pNode, vFanins, fUpdateLevel, fUseZeros_ref, fUseDcs, fVerbose );
pManRef->timeRes += Abc_Clock() - clk;
        Vec_IntPush((*pGain_ref), pManRef->nLastGain);
 
// Resub
        // compute a reconvergence-driven cut
        vLeaves = Abc_NodeFindCut( pManCutRes, pNode, 0 );
//        vLeaves = Abc_CutFactorLarge( pNode, nCutMax );
pManRes->timeCut += Abc_Clock() - clk;
        // get the don't-cares
        if ( pManOdc )
        {
clk = Abc_Clock();
            Abc_NtkDontCareClear( pManOdc );
            Abc_NtkDontCareCompute( pManOdc, pNode, vLeaves, pManRes->pCareSet );
pManRes->timeTruth += Abc_Clock() - clk;
        }
        // evaluate this cut
clk = Abc_Clock();
        pFFormRes = Abc_ManResubEval( pManRes, pNode, vLeaves, nStepsMax, fUpdateLevel, fVerbose );
//        Vec_PtrFree( vLeaves );
//        Abc_ManResubCleanup( pManRes );
pManRes->timeRes += Abc_Clock() - clk;
        // put nGain in Vector
        Vec_IntPush((*pGain_res), pManRes->nLastGain);
        // printf("size of vector %d\n", (**pGain).nSize);
 
// Rewrite
        nGain = Rwr_NodeRewrite( pManRwr, pManCutRwr, pNode, fUpdateLevel, fUseZeros, fPlaceEnable );
        nGain_zeros = Rwr_NodeRewrite( pManRwr, pManCutRwr, pNode, fUpdateLevel, fUseZeros_rwr, fPlaceEnable );
        Vec_IntPush( (*pGain_rwr), nGain);
 
        //printf("Res Ochestration: %d\n", pManRes->nLastGain);
        //printf("Ref Ochestration: %d\n", pManRef->nLastGain);
        //printf("Rwr Ochestration: %d\n", nGain);
        fprintf(fpt, "%d, %s, %d, %s, %d, %s, %d, %s, %d\n", pNode->Id, "Oches_Res", pManRes->nLastGain, "Oches_Ref", pManRef->nLastGain, "Oches_Rwr", nGain, "Oches_Rwr_Zeros", nGain_zeros);
 
        //fprintf(fpt, "%d, %s, %d, %s, %d, %s, %d, %s, %d\n", pNode->Id, "Oches_Res", pManRes->nLastGain, "Oches_Ref", pManRef->nLastGain, "Oches_Rwr", nGain, "Oches_Rwr_Zeros", nGain_zeros);
      
// Generate the valid operator array for the node
      if ( nGain > 0 )
      {   
          rwr_ok = 1;
          Vec_IntPush((*pOps_num), 0);
      }
      //if ( nGain_zeros > 0 )
      //{
      //    Vec_IntPush((*pOps_num), 1);
      //}
      //take refactor put
 
      if ( pManRef->nLastGain > 0 )
      {   
          ref_ok = 1;
          Vec_IntPush((*pOps_num), 2);
          //Vec_IntPush((*pOps_num), 3);
      }
 
      if ( pManRes->nLastGain > 0 )
      {   
          res_ok = 1;
          Vec_IntPush((*pOps_num), 1);
      }
// No available updats
      //if (! (nGain > 0 || nGain_zeros > 0 || pManRef->nLastGain > 0 || pManRes->nLastGain > 0 || (nGain == 0 && fUseZeros_rwr)))
      //if (! (nGain > 0 ||(nGain == 0 && fUseZeros_rwr)))
        //{
        //ops_null++;
        //continue;
        //}
       if (! ((**pOps_num).nSize > 0))
       {
       fprintf(fpt, "%d, %d, %d, %d, %d\n", pNode->Id, 0, 0, 0, 0);
       ops_null++;
       continue;
       }
/*
        if (pManRes->nLastGain > 0){
            res_ok = 1;
        }
        if (pManRef->nLastGain > 0){
            ref_ok = 1;
        }
        if (nGain > 0){
            rwr_ok = 1;
        }
*/
 
      //printf("available operations: %d.\n", (**pOps_num).nSize);
// Randomly pick a operation number
      //int Ops_num = 0;
      int Ops_size = (**pOps_num).nSize;
      int r = rand() % Ops_size;
      int Ops_num = (**pOps_num).pArray[r];
      //printf("the picked operation: %d.\n", Ops_num);
 
// Update the graph with random picked operation!
      if ( Ops_num == 0)
      {
// Graph update with Rewrite
        //printf("Graph Update with Rewrite");
        decisionOps = 1;
        ops_rwr++;
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
        if ( fCompl ) Dec_GraphComplement( pGraph );
        //printf("Nodes ID: %d\n", pNode->Id);
        fprintf(fpt, "%d, %d, %d, %d, %d\n", pNode->Id, rwr_ok, ref_ok, res_ok, decisionOps);
        continue;
      }
/*
      if ( Ops_num == 1)
      {
// Graph update with Rewrite -z
        //printf("Graph Update with Rewrite -z");
        ops_rwr_z++;
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain_zeros );
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
        if ( fCompl ) Dec_GraphComplement( pGraph );
        continue;
      }
*/      
      if ( Ops_num == 2)
      {
// Graph update with Refactor
        //printf("Graph Update with Refactor");
        decisionOps = 2;
        ops_ref++;
        if ( pFFormRef == NULL )
            continue;
clk = Abc_Clock();
        if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef, fUpdateLevel, pManRef->nLastGain ) )
                 {
                     Dec_GraphFree( pFFormRef );
                     RetValue = -1;
                     break;
                 }
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRef );
        fprintf(fpt, "%d, %d, %d, %d, %d\n", pNode->Id, rwr_ok, ref_ok, res_ok, decisionOps);
        continue;
      }
/*     
      if ( Ops_num == 3)
      {
// Graph update with Refactor -z
        //printf("Graph Update with Refactor");
        ops_ref_z++;
        if ( pFFormRef_zeros == NULL )
            continue;
clk = Abc_Clock();
        if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef_zeros, fUpdateLevel, pManRef->nLastGain ) )
                 {
                     Dec_GraphFree( pFFormRef_zeros );
                     RetValue = -1;
                     break;
                 }
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRef_zeros );
        continue;
      }
*/
 
      if (Ops_num == 1)
      {
// Graph update with Resub
        //printf("Graph Update with Resub");
        decisionOps = 3;
        ops_res++;
        if ( pFFormRes == NULL )
            continue;
        pManRes->nTotalGain += pManRes->nLastGain;
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pFFormRes, fUpdateLevel, pManRes->nLastGain );
pManRes->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRes );
        fprintf(fpt, "%d, %d, %d, %d, %d\n", pNode->Id, rwr_ok, ref_ok, res_ok, decisionOps);
        continue;
        }
 
    }
 
    fclose(fpt);
   
    /* 
    printf("size of vector %d\n", (**pGain_rwr).nSize);
    printf("nGain in vector: %d\n", (**pGain_res).pArray[20]);
    printf("Nodes with rewrite: %d\n", ops_rwr);
    //printf("Nodes with rewrite -z: %d\n", ops_rwr_z);
    printf("Nodes with resub: %d\n", ops_res);
    printf("Nodes with refactor: %d\n", ops_ref);
    //printf("Nodes with refactor -z: %d\n", ops_ref_z);
    printf("Nodes without updates: %d\n", ops_null);
    */
    Extra_ProgressBarStop( pProgress );
// Rewrite
Rwr_ManAddTimeTotal( pManRwr, Abc_Clock() - clkStart );
    pManRwr->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
// Resub
pManRes->timeTotal = Abc_Clock() - clkStart;
    pManRes->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
// Refactor
pManRef->timeTotal = Abc_Clock() - clkStart;
    pManRef->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
    // print statistics
    if ( fVerbose ){
        Abc_ManResubPrint( pManRes );
        Rwr_ManPrintStats( pManRwr );
        Abc_NtkManRefPrintStats_1( pManRef );
    }
    if ( fVeryVerbose )
        Rwr_ScoresReport( pManRwr );
    // delete the managers
    // resub
    Abc_ManResubStop( pManRes );
    Abc_NtkManCutStop( pManCutRes );
    // rewrite
    Rwr_ManStop( pManRwr );
    Cut_ManStop( pManCutRwr );
    pNtk->pManCut = NULL;
    // refactor
    Abc_NtkManCutStop( pManCutRef );
    Abc_NtkManRefStop_1( pManRef );
 
    if ( pManOdc ) Abc_NtkDontCareFree( pManOdc );
 
    // clean the data field
    Abc_NtkForEachObj( pNtk, pNode, i )
        pNode->pData = NULL;
 
    if ( Abc_NtkLatchNum(pNtk) ) {
        Abc_NtkForEachLatch(pNtk, pNode, i)
            pNode->pData = pNode->pNext, pNode->pNext = NULL;
    }
 
    // put the nodes into the DFS order and reassign their IDs
    Abc_NtkReassignIds( pNtk );
//    Abc_AigCheckFaninOrder( pNtk->pManFunc );
 
    // fix the levels
    if ( fUpdateLevel )
        Abc_NtkStopReverseLevels( pNtk );
    else
        Abc_NtkLevel( pNtk );
    // check
    if ( !Abc_NtkCheck( pNtk ) )
    {
        printf( "Abc_NtkOchestraction: The network check has failed.\n" );
        return 0;
    }
s_ResubTime = Abc_Clock() - clkStart;
    return 1;
}

Here is the call graph for this function:

Abc_NtkOchestration3()

int Abc_NtkOchestration3	(	Abc_Ntk_t *	pNtk,
		Vec_Int_t **	pGain_rwr,
		Vec_Int_t **	pGain_res,
		Vec_Int_t **	pGain_ref,
		Vec_Int_t **	pOps_num,
		int	fUseZeros,
		int	fUseZeros_rwr,
		int	fUseZeros_ref,
		int	fPlaceEnable,
		int	nCutMax,
		int	nStepsMax,
		int	nLevelsOdc,
		int	fUpdateLevel,
		int	fVerbose,
		int	fVeryVerbose,
		int	nNodeSizeMax,
		int	nConeSizeMax,
		int	fUseDcs )

Definition at line 4351 of file abcOrchestration.c.

{
    ProgressBar * pProgress;
    // For resub
    Abc_ManRes_t * pManRes;
    Abc_ManCut_t * pManCutRes;
    Odc_Man_t * pManOdc = NULL;
    Dec_Graph_t * pFFormRes;
    Dec_Graph_t * pFFormRef_zeros;
    Vec_Ptr_t * vLeaves;
    // For rewrite
    Cut_Man_t * pManCutRwr;
    Rwr_Man_t * pManRwr;
    Dec_Graph_t * pGraph;
    // For refactor
    Abc_ManRef_t * pManRef;
    Abc_ManCut_t * pManCutRef;
    Dec_Graph_t * pFFormRef;
    Vec_Ptr_t * vFanins;
 
    Abc_Obj_t * pNode;
    FILE *fpt;
    abctime clk, clkStart = Abc_Clock();
    abctime s_ResubTime;
    int i, nNodes, nGain, nGain_zeros, fCompl, RetValue = 1;
    int ops_rwr = 0;
    int ops_rwr_z = 0;
    int ops_res = 0;
    int ops_ref_z = 0;
    int ops_ref = 0;
    int ops_null = 0;
    assert( Abc_NtkIsStrash(pNtk) );
 
    // cleanup the AIG
    Abc_AigCleanup((Abc_Aig_t *)pNtk->pManFunc);
 
    // start the managers resub
    pManCutRes = Abc_NtkManCutStart( nCutMax, 100000, 100000, 100000 );
    pManRes = Abc_ManResubStart( nCutMax, ABC_RS_DIV1_MAX );
    if ( nLevelsOdc > 0 )
    pManOdc = Abc_NtkDontCareAlloc( nCutMax, nLevelsOdc, fVerbose, fVeryVerbose );
    // start the managers refactor
    pManCutRef = Abc_NtkManCutStart( nNodeSizeMax, nConeSizeMax, 2, 1000 );
    pManRef = Abc_NtkManRefStart_1( nNodeSizeMax, nConeSizeMax, fUseDcs, fVerbose );
    pManRef->vLeaves   = Abc_NtkManCutReadCutLarge( pManCutRef );
    // start the managers rewrite
    pManRwr = Rwr_ManStart( 0 );
    if ( pManRwr == NULL )
        return 0;
 
    // compute the reverse levels if level update is requested
    if ( fUpdateLevel )
        Abc_NtkStartReverseLevels( pNtk, 0 );
 
    // 'Resub only'
    if ( Abc_NtkLatchNum(pNtk) ) {
        Abc_NtkForEachLatch(pNtk, pNode, i)
            pNode->pNext = (Abc_Obj_t *)pNode->pData;
    }
    // cut manager for rewrite
clk = Abc_Clock();
    pManCutRwr = Abc_NtkStartCutManForRewrite( pNtk );
Rwr_ManAddTimeCuts( pManRwr, Abc_Clock() - clk );
    pNtk->pManCut = pManCutRwr;
 
    if ( fVeryVerbose )
        Rwr_ScoresClean( pManRwr );
 
  // resynthesize each node once
  // resub
    pManRes->nNodesBeg = Abc_NtkNodeNum(pNtk);
  // rewrite
    pManRwr->nNodesBeg = Abc_NtkNodeNum(pNtk);
  // refactor
    pManRef->nNodesBeg = Abc_NtkNodeNum(pNtk);
 
    nNodes = Abc_NtkObjNumMax(pNtk);
    //printf("nNodes: %d\n", nNodes);
    if (pGain_res) *pGain_res = Vec_IntAlloc(1);
    if (pGain_ref) *pGain_ref = Vec_IntAlloc(1);
    if (pGain_rwr) *pGain_rwr = Vec_IntAlloc(1);
 
    pProgress = Extra_ProgressBarStart( stdout, nNodes );
    fpt = fopen("Ochestration_id_ops_nGain.csv", "w");
 
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
    if (pOps_num) *pOps_num = Vec_IntAlloc(1);
        //printf("Ochestration id: %d\n", pNode->Id);
        Extra_ProgressBarUpdate( pProgress, i, NULL );
        // skip the constant node
//        if ( Abc_NodeIsConst(pNode) )
//            continue;
        // skip persistant nodes
        if ( Abc_NodeIsPersistant(pNode) )
        {
            if (!(pGain_res && pGain_ref && pGain_rwr))
                return 0;
            fprintf(fpt, "%d, %s, %d\n", pNode->Id, "None" , -99);
            Vec_IntPush((*pGain_res), -99);
            Vec_IntPush((*pGain_ref), -99);
            Vec_IntPush((*pGain_rwr), -99);
            continue;
        } 
        // skip the nodes with many fanouts
        if ( Abc_ObjFanoutNum(pNode) > 1000 )
        {
            if (!(pGain_res && pGain_ref && pGain_rwr))
                return 0;
            fprintf(fpt, "%d, %s, %d\n", pNode->Id,"None", -99);
            Vec_IntPush((*pGain_res), -99);
            Vec_IntPush((*pGain_ref), -99);
            Vec_IntPush((*pGain_rwr), -99);
            continue;
        }
        // stop if all nodes have been tried once
        if ( i >= nNodes )
            break;
clk = Abc_Clock();
 
//Refactor
        vFanins = Abc_NodeFindCut( pManCutRef, pNode, fUseDcs );
pManRef->timeCut += Abc_Clock() - clk;
clk = Abc_Clock();
        pFFormRef = Abc_NodeRefactor_1( pManRef, pNode, vFanins, fUpdateLevel, fUseZeros, fUseDcs, fVerbose );
        pFFormRef_zeros = Abc_NodeRefactor_1( pManRef, pNode, vFanins, fUpdateLevel, fUseZeros_ref, fUseDcs, fVerbose );
pManRef->timeRes += Abc_Clock() - clk;
        Vec_IntPush((*pGain_ref), pManRef->nLastGain);
 
// Resub
        // compute a reconvergence-driven cut
        vLeaves = Abc_NodeFindCut( pManCutRes, pNode, 0 );
//        vLeaves = Abc_CutFactorLarge( pNode, nCutMax );
pManRes->timeCut += Abc_Clock() - clk;
        // get the don't-cares
        if ( pManOdc )
        {
clk = Abc_Clock();
            Abc_NtkDontCareClear( pManOdc );
            Abc_NtkDontCareCompute( pManOdc, pNode, vLeaves, pManRes->pCareSet );
pManRes->timeTruth += Abc_Clock() - clk;
        }
        // evaluate this cut
clk = Abc_Clock();
        pFFormRes = Abc_ManResubEval( pManRes, pNode, vLeaves, nStepsMax, fUpdateLevel, fVerbose );
//        Vec_PtrFree( vLeaves );
//        Abc_ManResubCleanup( pManRes );
pManRes->timeRes += Abc_Clock() - clk;
        // put nGain in Vector
        Vec_IntPush((*pGain_res), pManRes->nLastGain);
        // printf("size of vector %d\n", (**pGain).nSize);
 
// Rewrite
        nGain = Rwr_NodeRewrite( pManRwr, pManCutRwr, pNode, fUpdateLevel, fUseZeros, fPlaceEnable );
        nGain_zeros = Rwr_NodeRewrite( pManRwr, pManCutRwr, pNode, fUpdateLevel, fUseZeros_rwr, fPlaceEnable );
        Vec_IntPush( (*pGain_rwr), nGain);
 
        //printf("Res Ochestration: %d\n", pManRes->nLastGain);
        //printf("Ref Ochestration: %d\n", pManRef->nLastGain);
        //printf("Rwr Ochestration: %d\n", nGain);
        fprintf(fpt, "%d, %s, %d, %s, %d, %s, %d, %s, %d\n", pNode->Id, "Oches_Res", pManRes->nLastGain, "Oches_Ref", pManRef->nLastGain, "Oches_Rwr", nGain, "Oches_Rwr_Zeros", nGain_zeros);
      
// Generate the valid operator array for the node
      if ( nGain > 0 )
      {
          Vec_IntPush((*pOps_num), 0);
      }
      if ( nGain_zeros > 0 )
      {
          Vec_IntPush((*pOps_num), 1);
      }
      if ( pManRef->nLastGain > 0 )
      {
          Vec_IntPush((*pOps_num), 2);
          Vec_IntPush((*pOps_num), 3);
      }
      if ( pManRes->nLastGain > 0 )
      {
          Vec_IntPush((*pOps_num), 4);
      }
// No available updats
      //if (! (nGain > 0 || nGain_zeros > 0 || pManRef->nLastGain > 0 || pManRes->nLastGain > 0 || (nGain == 0 && fUseZeros_rwr)))
      //if (! (nGain > 0 ||(nGain == 0 && fUseZeros_rwr)))
        //{
        //ops_null++;
        //continue;
        //}
       if (! ((**pOps_num).nSize > 0))
       {
       ops_null++;
       continue;
       }
 
      //printf("available operations: %d.\n", (**pOps_num).nSize);
// Randomly pick a operation number
      //int Ops_num = 0;
      int Ops_size = (**pOps_num).nSize;
      int r = rand() % Ops_size;
      int Ops_num = (**pOps_num).pArray[r];
      //printf("the picked operation: %d.\n", Ops_num);
 
// Update the graph with random picked operation!
      if ( Ops_num == 0)
      {
// Graph update with Rewrite
        //printf("Graph Update with Rewrite");
        ops_rwr++;
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
        if ( fCompl ) Dec_GraphComplement( pGraph );
        continue;
      }
 
      if ( Ops_num == 1)
      {
// Graph update with Rewrite -z
        //printf("Graph Update with Rewrite -z");
        ops_rwr_z++;
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain_zeros );
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
        if ( fCompl ) Dec_GraphComplement( pGraph );
        continue;
      }
      
      if ( Ops_num == 2)
      {
// Graph update with Refactor
        //printf("Graph Update with Refactor");
        ops_ref++;
        if ( pFFormRef == NULL )
            continue;
clk = Abc_Clock();
        if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef, fUpdateLevel, pManRef->nLastGain ) )
                 {
                     Dec_GraphFree( pFFormRef );
                     RetValue = -1;
                     break;
                 }
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRef );
        continue;
      }
     
      if ( Ops_num == 3)
      {
// Graph update with Refactor -z
        //printf("Graph Update with Refactor");
        ops_ref_z++;
        if ( pFFormRef_zeros == NULL )
            continue;
clk = Abc_Clock();
        if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef_zeros, fUpdateLevel, pManRef->nLastGain ) )
                 {
                     Dec_GraphFree( pFFormRef_zeros );
                     RetValue = -1;
                     break;
                 }
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRef_zeros );
        continue;
      }
 
      if (Ops_num == 4)
      {
// Graph update with Resub
        //printf("Graph Update with Resub");
        ops_res++;
        if ( pFFormRes == NULL )
            continue;
        pManRes->nTotalGain += pManRes->nLastGain;
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pFFormRes, fUpdateLevel, pManRes->nLastGain );
pManRes->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRes );
        continue;
        }
 
    }
 
    fclose(fpt);
    /*
    printf("size of vector %d\n", (**pGain_rwr).nSize);
    printf("nGain in vector: %d\n", (**pGain_res).pArray[20]);
    printf("Nodes with rewrite: %d\n", ops_rwr);
    printf("Nodes with rewrite -z: %d\n", ops_rwr_z);
    printf("Nodes with resub: %d\n", ops_res);
    printf("Nodes with refactor: %d\n", ops_ref);
    printf("Nodes with refactor -z: %d\n", ops_ref_z);
    printf("Nodes without updates: %d\n", ops_null);
    */
    Extra_ProgressBarStop( pProgress );
// Rewrite
Rwr_ManAddTimeTotal( pManRwr, Abc_Clock() - clkStart );
    pManRwr->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
// Resub
pManRes->timeTotal = Abc_Clock() - clkStart;
    pManRes->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
// Refactor
pManRef->timeTotal = Abc_Clock() - clkStart;
    pManRef->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
    // print statistics
    if ( fVerbose ){
        Abc_ManResubPrint( pManRes );
        Rwr_ManPrintStats( pManRwr );
        Abc_NtkManRefPrintStats_1( pManRef );
    }
    if ( fVeryVerbose )
        Rwr_ScoresReport( pManRwr );
    // delete the managers
    // resub
    Abc_ManResubStop( pManRes );
    Abc_NtkManCutStop( pManCutRes );
    // rewrite
    Rwr_ManStop( pManRwr );
    Cut_ManStop( pManCutRwr );
    pNtk->pManCut = NULL;
    // refactor
    Abc_NtkManCutStop( pManCutRef );
    Abc_NtkManRefStop_1( pManRef );
 
    if ( pManOdc ) Abc_NtkDontCareFree( pManOdc );
 
    // clean the data field
    Abc_NtkForEachObj( pNtk, pNode, i )
        pNode->pData = NULL;
 
    if ( Abc_NtkLatchNum(pNtk) ) {
        Abc_NtkForEachLatch(pNtk, pNode, i)
            pNode->pData = pNode->pNext, pNode->pNext = NULL;
    }
 
    // put the nodes into the DFS order and reassign their IDs
    Abc_NtkReassignIds( pNtk );
//    Abc_AigCheckFaninOrder( pNtk->pManFunc );
 
    // fix the levels
    if ( fUpdateLevel )
        Abc_NtkStopReverseLevels( pNtk );
    else
        Abc_NtkLevel( pNtk );
    // check
    if ( !Abc_NtkCheck( pNtk ) )
    {
        printf( "Abc_NtkOchestraction: The network check has failed.\n" );
        return 0;
    }
s_ResubTime = Abc_Clock() - clkStart;
    return 1;
}

Here is the call graph for this function:

Abc_NtkOrchGNN()

int Abc_NtkOrchGNN	(	Abc_Ntk_t *	pNtk,
		char *	edgelistFile,
		char *	featFile,
		int	fUseZeros,
		int	fUseZeros_rwr,
		int	fUseZeros_ref,
		int	fPlaceEnable,
		int	nCutMax,
		int	nStepsMax,
		int	nLevelsOdc,
		int	fUpdateLevel,
		int	fVerbose,
		int	fVeryVerbose,
		int	nNodeSizeMax,
		int	nConeSizeMax,
		int	fUseDcs )

Definition at line 5114 of file abcOrchestration.c.

{
    ProgressBar * pProgress;
    // For resub
    Abc_ManRes_t * pManRes;
    Abc_ManCut_t * pManCutRes;
    Odc_Man_t * pManOdc = NULL;
    Dec_Graph_t * pFFormRes;
    Dec_Graph_t * pFFormRef_zeros;
    Vec_Ptr_t * vLeaves;
    // For rewrite
    Cut_Man_t * pManCutRwr;
    Rwr_Man_t * pManRwr;
    //Dec_Graph_t * pGraph;
    // For refactor
    Abc_ManRef_t * pManRef;
    Abc_ManCut_t * pManCutRef;
    Dec_Graph_t * pFFormRef;
    Vec_Ptr_t * vFanins;
 
    Abc_Obj_t * pNode, * pFanin;
    int fanin_i;
    FILE * f_el;
    FILE * f_feats;
    //FILE * fpt;
    abctime clk, clkStart = Abc_Clock();
    abctime s_ResubTime;
    int i, nNodes, nGain, nGain_zeros;//, fCompl, RetValue = 1;
    int rwr_ok = 0;
    int res_ok = 0;
    int ref_ok = 0;
    //int decisionOps = 0;
    assert( Abc_NtkIsStrash(pNtk) );
 
    // cleanup the AIG
    Abc_AigCleanup((Abc_Aig_t *)pNtk->pManFunc);
 
    // start the managers resub
    pManCutRes = Abc_NtkManCutStart( nCutMax, 100000, 100000, 100000 );
    pManRes = Abc_ManResubStart( nCutMax, ABC_RS_DIV1_MAX );
    if ( nLevelsOdc > 0 )
    pManOdc = Abc_NtkDontCareAlloc( nCutMax, nLevelsOdc, fVerbose, fVeryVerbose );
    // start the managers refactor
    pManCutRef = Abc_NtkManCutStart( nNodeSizeMax, nConeSizeMax, 2, 1000 );
    pManRef = Abc_NtkManRefStart_1( nNodeSizeMax, nConeSizeMax, fUseDcs, fVerbose );
    pManRef->vLeaves   = Abc_NtkManCutReadCutLarge( pManCutRef );
    // start the managers rewrite
    pManRwr = Rwr_ManStart( 0 );
    if ( pManRwr == NULL )
        return 0;
 
    // compute the reverse levels if level update is requested
    if ( fUpdateLevel )
        Abc_NtkStartReverseLevels( pNtk, 0 );
 
    // 'Resub only'
    if ( Abc_NtkLatchNum(pNtk) ) {
        Abc_NtkForEachLatch(pNtk, pNode, i)
            pNode->pNext = (Abc_Obj_t *)pNode->pData;
    }
    // cut manager for rewrite
clk = Abc_Clock();
    pManCutRwr = Abc_NtkStartCutManForRewrite( pNtk );
Rwr_ManAddTimeCuts( pManRwr, Abc_Clock() - clk );
    pNtk->pManCut = pManCutRwr;
 
    if ( fVeryVerbose )
        Rwr_ScoresClean( pManRwr );
 
  // resynthesize each node once
  // resub
    pManRes->nNodesBeg = Abc_NtkNodeNum(pNtk);
  // rewrite
    pManRwr->nNodesBeg = Abc_NtkNodeNum(pNtk);
  // refactor
    pManRef->nNodesBeg = Abc_NtkNodeNum(pNtk);
 
    nNodes = Abc_NtkObjNumMax(pNtk);
    //printf("nNodes: %d\n", nNodes);
    //if (pGain_res) *pGain_res = Vec_IntAlloc(1);
    //if (pGain_ref) *pGain_ref = Vec_IntAlloc(1);
    //if (pGain_rwr) *pGain_rwr = Vec_IntAlloc(1);
 
    pProgress = Extra_ProgressBarStart( stdout, nNodes );
    //fpt = fopen("GNN_Embedding.csv", "w");
    f_el = fopen(edgelistFile, "w");
    f_feats = fopen(featFile, "w");
 
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        int iterNode = pNode->Id;
        Abc_ObjForEachFanin(pNode, pFanin, fanin_i){
            fprintf(f_el, "%d %d\n", iterNode, Abc_ObjId(pFanin));
        }
        //printf("Nodes ID: %d\n", pNode->Id);
        rwr_ok = 0;
        ref_ok = 0;
        res_ok = 0;
        Extra_ProgressBarUpdate( pProgress, i, NULL );
        // skip the constant node
//        if ( Abc_NodeIsConst(pNode) )
//            continue;
        // skip persistant nodes
 
        if ( Abc_NodeIsPersistant(pNode) )
        {   
            //fprintf(f_el, "%d %d\n", iterNode, Abc_ObjId(pFanin));
            fprintf(f_feats, "%d, %d, %d, %d, %d, %d, %d, %d\n", Abc_ObjFaninC0(pNode), Abc_ObjFaninC1(pNode), -1, -1, -1, -1, -1, -1);
            //fprintf(fpt, "%d, %d, %d, %d, %d, %d, %d, %d, %d,  %d\n", iterNode, Abc_ObjId(pFanin), Abc_ObjFaninC0(pNode), Abc_ObjFaninC1(pNode), -1, -1, -1, -1, -1, -1);
            continue;
        } 
        // skip the nodes with many fanouts
        if ( Abc_ObjFanoutNum(pNode) > 1000 )
        {
            //fprintf(f_el, "%d %d\n", iterNode, Abc_ObjId(pFanin));
            fprintf(f_feats, "%d, %d, %d, %d, %d, %d, %d, %d\n", Abc_ObjFaninC0(pNode), Abc_ObjFaninC1(pNode), -1, -1, -1, -1, -1, -1);
            //fprintf(fpt, "%d, %d, %d, %d, %d, %d, %d, %d, %d, %d\n", iterNode, Abc_ObjId(pFanin), Abc_ObjFaninC0(pNode), Abc_ObjFaninC1(pNode), -1, -1, -1, -1, -1, -1);
            continue;
        }
        // stop if all nodes have been tried once
        if ( i >= nNodes )
            break;
        
clk = Abc_Clock();
 
//Refactor
        vFanins = Abc_NodeFindCut( pManCutRef, pNode, fUseDcs );
pManRef->timeCut += Abc_Clock() - clk;
clk = Abc_Clock();
        pFFormRef = Abc_NodeRefactor_1( pManRef, pNode, vFanins, fUpdateLevel, fUseZeros, fUseDcs, fVerbose );
        pFFormRef_zeros = Abc_NodeRefactor_1( pManRef, pNode, vFanins, fUpdateLevel, fUseZeros_ref, fUseDcs, fVerbose );
pManRef->timeRes += Abc_Clock() - clk;
        if (! (pManRef->nLastGain < 0) ) {ref_ok = 1;}
 
// Resub
        // compute a reconvergence-driven cut
        vLeaves = Abc_NodeFindCut( pManCutRes, pNode, 0 );
//        vLeaves = Abc_CutFactorLarge( pNode, nCutMax );
pManRes->timeCut += Abc_Clock() - clk;
        // get the don't-cares
        if ( pManOdc )
        {
clk = Abc_Clock();
            Abc_NtkDontCareClear( pManOdc );
            Abc_NtkDontCareCompute( pManOdc, pNode, vLeaves, pManRes->pCareSet );
pManRes->timeTruth += Abc_Clock() - clk;
        }
        // evaluate this cut
clk = Abc_Clock();
        pFFormRes = Abc_ManResubEval( pManRes, pNode, vLeaves, nStepsMax, fUpdateLevel, fVerbose );
//        Vec_PtrFree( vLeaves );
//        Abc_ManResubCleanup( pManRes );
pManRes->timeRes += Abc_Clock() - clk;
        // put nGain in Vector
        if (! (pManRes->nLastGain < 0) ) {res_ok = 1;}
 
// Rewrite
        nGain = Rwr_NodeRewrite( pManRwr, pManCutRwr, pNode, fUpdateLevel, fUseZeros, fPlaceEnable );
        nGain_zeros = Rwr_NodeRewrite( pManRwr, pManCutRwr, pNode, fUpdateLevel, fUseZeros_rwr, fPlaceEnable );
        if (! (nGain < 0) ) {rwr_ok = 1;}
 
        //fprintf(f_el, "%d %d\n", iterNode, Abc_ObjId(pFanin));
        fprintf(f_feats, "%d, %d, %d, %d, %d, %d, %d, %d\n", Abc_ObjFaninC0(pNode), Abc_ObjFaninC1(pNode), rwr_ok, nGain, res_ok, pManRes->nLastGain, ref_ok, pManRef->nLastGain);
        //fprintf(fpt, "%d, %d, %d, %d, %d, %d, %d, %d, %d, %d\n", iterNode, Abc_ObjId(pFanin), Abc_ObjFaninC0(pNode), Abc_ObjFaninC1(pNode), rwr_ok, nGain, res_ok, pManRes->nLastGain, ref_ok, pManRef->nLastGain);
        //printf("Res Ochestration: %d\n", pManRes->nLastGain);
        //printf("Ref Ochestration: %d\n", pManRef->nLastGain);
        //printf("Rwr Ochestration: %d\n", nGain);
 
     //continue; 
     //}
     //continue; 
    }
    fclose(f_el);
    fclose(f_feats);
    //fclose(fpt);
    
    
    Extra_ProgressBarStop( pProgress );
// Rewrite
Rwr_ManAddTimeTotal( pManRwr, Abc_Clock() - clkStart );
    pManRwr->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
// Resub
pManRes->timeTotal = Abc_Clock() - clkStart;
    pManRes->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
// Refactor
pManRef->timeTotal = Abc_Clock() - clkStart;
    pManRef->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
    // print statistics
    if ( fVerbose ){
        Abc_ManResubPrint( pManRes );
        Rwr_ManPrintStats( pManRwr );
        Abc_NtkManRefPrintStats_1( pManRef );
    }
    if ( fVeryVerbose )
        Rwr_ScoresReport( pManRwr );
    // delete the managers
    // resub
    Abc_ManResubStop( pManRes );
    Abc_NtkManCutStop( pManCutRes );
    // rewrite
    Rwr_ManStop( pManRwr );
    Cut_ManStop( pManCutRwr );
    pNtk->pManCut = NULL;
    // refactor
    Abc_NtkManCutStop( pManCutRef );
    Abc_NtkManRefStop_1( pManRef );
 
    if ( pManOdc ) Abc_NtkDontCareFree( pManOdc );
 
    // clean the data field
    Abc_NtkForEachObj( pNtk, pNode, i )
        pNode->pData = NULL;
 
    if ( Abc_NtkLatchNum(pNtk) ) {
        Abc_NtkForEachLatch(pNtk, pNode, i)
            pNode->pData = pNode->pNext, pNode->pNext = NULL;
    }
 
    // put the nodes into the DFS order and reassign their IDs
    Abc_NtkReassignIds( pNtk );
//    Abc_AigCheckFaninOrder( pNtk->pManFunc );
 
    // fix the levels
    if ( fUpdateLevel )
        Abc_NtkStopReverseLevels( pNtk );
    else
        Abc_NtkLevel( pNtk );
    // check
    if ( !Abc_NtkCheck( pNtk ) )
    {
        printf( "Abc_NtkOchestraction: The network check has failed.\n" );
        return 0;
    }
s_ResubTime = Abc_Clock() - clkStart;
    return 1;
}

Here is the call graph for this function:

Abc_NtkOrchLocal()

int Abc_NtkOrchLocal	(	Abc_Ntk_t *	pNtk,
		int	fUseZeros_rwr,
		int	fUseZeros_ref,
		int	fPlaceEnable,
		int	nCutMax,
		int	nStepsMax,
		int	nLevelsOdc,
		int	fUpdateLevel,
		int	fVerbose,
		int	fVeryVerbose,
		int	nNodeSizeMax,
		int	nConeSizeMax,
		int	fUseDcs )

Definition at line 3231 of file abcOrchestration.c.

{
    ProgressBar * pProgress;
    // For resub
    Abc_ManRes_t * pManRes;
    Abc_ManCut_t * pManCutRes;
    Odc_Man_t * pManOdc = NULL;
    Dec_Graph_t * pFFormRes;
    //Dec_Graph_t * pFFormRef_zeros;
    Vec_Ptr_t * vLeaves;
    // For rewrite
    Cut_Man_t * pManCutRwr;
    Rwr_Man_t * pManRwr;
    Dec_Graph_t * pGraph;
    // For refactor
    Abc_ManRef_t * pManRef;
    Abc_ManCut_t * pManCutRef;
    Dec_Graph_t * pFFormRef;
    Vec_Ptr_t * vFanins;
 
    Abc_Obj_t * pNode;//, * pFanin;
    //int fanin_i;
    //FILE * fpt;
    abctime clk, clkStart = Abc_Clock();
    abctime s_ResubTime;
    int i, nNodes, nGain, fCompl, RetValue = 1;//, nGain_zeros;
    //int decisionOps = 0;
    int ops_rwr = 0;
    int ops_res = 0;
    int ops_ref = 0;
    int ops_null = 0;
    assert( Abc_NtkIsStrash(pNtk) );
 
    // cleanup the AIG
    Abc_AigCleanup((Abc_Aig_t *)pNtk->pManFunc);
 
    // start the managers resub
    pManCutRes = Abc_NtkManCutStart( nCutMax, 100000, 100000, 100000 );
    pManRes = Abc_ManResubStart( nCutMax, ABC_RS_DIV1_MAX );
    if ( nLevelsOdc > 0 )
    pManOdc = Abc_NtkDontCareAlloc( nCutMax, nLevelsOdc, fVerbose, fVeryVerbose );
    // start the managers refactor
    pManCutRef = Abc_NtkManCutStart( nNodeSizeMax, nConeSizeMax, 2, 1000 );
    pManRef = Abc_NtkManRefStart_1( nNodeSizeMax, nConeSizeMax, fUseDcs, fVerbose );
    pManRef->vLeaves   = Abc_NtkManCutReadCutLarge( pManCutRef );
    // start the managers rewrite
    pManRwr = Rwr_ManStart( 0 );
    if ( pManRwr == NULL )
        return 0;
 
    // compute the reverse levels if level update is requested
    if ( fUpdateLevel )
        Abc_NtkStartReverseLevels( pNtk, 0 );
 
    // 'Resub only'
    if ( Abc_NtkLatchNum(pNtk) ) {
        Abc_NtkForEachLatch(pNtk, pNode, i)
            pNode->pNext = (Abc_Obj_t *)pNode->pData;
    }
    // cut manager for rewrite
clk = Abc_Clock();
    pManCutRwr = Abc_NtkStartCutManForRewrite( pNtk );
Rwr_ManAddTimeCuts( pManRwr, Abc_Clock() - clk );
    pNtk->pManCut = pManCutRwr;
 
    if ( fVeryVerbose )
        Rwr_ScoresClean( pManRwr );
 
  // resynthesize each node once
  // resub
    pManRes->nNodesBeg = Abc_NtkNodeNum(pNtk);
  // rewrite
    pManRwr->nNodesBeg = Abc_NtkNodeNum(pNtk);
  // refactor
    pManRef->nNodesBeg = Abc_NtkNodeNum(pNtk);
 
    nNodes = Abc_NtkObjNumMax(pNtk);
    //printf("nNodes: %d\n", nNodes);
    //if (pGain_res) *pGain_res = Vec_IntAlloc(1);
    //if (pGain_ref) *pGain_ref = Vec_IntAlloc(1);
    //if (pGain_rwr) *pGain_rwr = Vec_IntAlloc(1);
 
    pProgress = Extra_ProgressBarStart( stdout, nNodes );
 
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        //int iterNode = pNode->Id;
        //printf("Nodes ID: %d\n", pNode->Id);
        Extra_ProgressBarUpdate( pProgress, i, NULL );
        // skip the constant node
//        if ( Abc_NodeIsConst(pNode) )
//            continue;
        // skip persistant nodes
 
        if ( Abc_NodeIsPersistant(pNode) )
        {   
            continue;
        } 
        // skip the nodes with many fanouts
        if ( Abc_ObjFanoutNum(pNode) > 1000 )
        {
            continue;
        }
        // stop if all nodes have been tried once
        if ( i >= nNodes )
            break;
        
clk = Abc_Clock();
 
//Refactor
        vFanins = Abc_NodeFindCut( pManCutRef, pNode, fUseDcs );
pManRef->timeCut += Abc_Clock() - clk;
clk = Abc_Clock();
        //pFFormRef = Abc_NodeRefactor_1( pManRef, pNode, vFanins, fUpdateLevel, fUseZeros, fUseDcs, fVerbose );
        pFFormRef = Abc_NodeRefactor_1( pManRef, pNode, vFanins, fUpdateLevel, fUseZeros_ref, fUseDcs, fVerbose );
pManRef->timeRes += Abc_Clock() - clk;
 
// Resub
        // compute a reconvergence-driven cut
        vLeaves = Abc_NodeFindCut( pManCutRes, pNode, 0 );
//        vLeaves = Abc_CutFactorLarge( pNode, nCutMax );
pManRes->timeCut += Abc_Clock() - clk;
        // get the don't-cares
        if ( pManOdc )
        {
clk = Abc_Clock();
            Abc_NtkDontCareClear( pManOdc );
            Abc_NtkDontCareCompute( pManOdc, pNode, vLeaves, pManRes->pCareSet );
pManRes->timeTruth += Abc_Clock() - clk;
        }
        // evaluate this cut
clk = Abc_Clock();
        pFFormRes = Abc_ManResubEval( pManRes, pNode, vLeaves, nStepsMax, fUpdateLevel, fVerbose );
//        Vec_PtrFree( vLeaves );
//        Abc_ManResubCleanup( pManRes );
pManRes->timeRes += Abc_Clock() - clk;
 
// Rewrite
        //nGain = Rwr_NodeRewrite( pManRwr, pManCutRwr, pNode, fUpdateLevel, fUseZeros, fPlaceEnable );
        nGain = Rwr_NodeRewrite( pManRwr, pManCutRwr, pNode, fUpdateLevel, fUseZeros_rwr, fPlaceEnable );
 
     // compare local reward and update
        // if (((! (nGain < 0)) && (! (nGain < pManRes->nLastGain)) && (! (pManRes->nLastGain < pManRef->nLastGain))) || ((! (nGain < 0)) && (! (nGain < pManRef->nLastGain)) && (! (pManRef->nLastGain < pManRes->nLastGain)))){
        if (((! (nGain < 0)) && (! (nGain < pManRes->nLastGain)) && (! (nGain < pManRef->nLastGain)))){
        // update with rewrite
            pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
            fCompl = Rwr_ManReadCompl(pManRwr);
            if ( fPlaceEnable )
                Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
            if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
            Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
            if ( fCompl ) Dec_GraphComplement( pGraph );
            ops_rwr++;
            if(pFFormRef != NULL){
                Dec_GraphFree( pFFormRef );
            }
            if(pFFormRes != NULL){
                Dec_GraphFree( pFFormRes );
            }
            continue;
        } 
        // if (((! (pManRes->nLastGain < 0)) && (! (pManRes->nLastGain < nGain)) && (! (nGain < pManRef->nLastGain))) || ((! (pManRes->nLastGain < 0)) && (! (pManRes->nLastGain < pManRef->nLastGain)) && (! (pManRef->nLastGain < nGain)))){
        if (((! (pManRes->nLastGain < 0)) && (! (pManRes->nLastGain < nGain)) && (! (pManRes->nLastGain < pManRef->nLastGain)))){
        // update with Resub
            if ( pFFormRes == NULL ) {
                if (pFFormRef != NULL) {
                    Dec_GraphFree(pFFormRef);
                }
                continue;
            }
            pManRes->nTotalGain += pManRes->nLastGain;
clk = Abc_Clock();
            Dec_GraphUpdateNetwork( pNode, pFFormRes, fUpdateLevel, pManRes->nLastGain );
pManRes->timeNtk += Abc_Clock() - clk;
            Dec_GraphFree( pFFormRes );
            ops_res++;
            if( pFFormRef != NULL ){
                Dec_GraphFree( pFFormRef);
            }
            continue;
        }
        // if (((! (pManRef->nLastGain < 0)) && (! (pManRef->nLastGain < nGain)) && (! (nGain < pManRes->nLastGain))) || ((! (pManRef->nLastGain < 0)) && (! (pManRef->nLastGain < pManRes->nLastGain)) && (! (pManRes->nLastGain < nGain)))){
        if (((! (pManRef->nLastGain < 0)) && (! (pManRef->nLastGain < nGain)) && (! (pManRef->nLastGain < pManRes->nLastGain)))){
        // update with Refactor
            if ( pFFormRef == NULL ) {
                if( pFFormRes != NULL) {
                    Dec_GraphFree(pFFormRes);
                }
                continue;
            }
clk = Abc_Clock();
            if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef, fUpdateLevel, pManRef->nLastGain ) )
                 {
                     Dec_GraphFree( pFFormRef );
                     RetValue = -1;
                     break;
                 }
pManRef->timeNtk += Abc_Clock() - clk;
            Dec_GraphFree( pFFormRef );
            ops_ref++;
            if(pFFormRes != NULL){
                Dec_GraphFree( pFFormRes );
            }
            continue;
        }
        else{
            ops_null++;
            if( pFFormRef != NULL ){
                Dec_GraphFree( pFFormRef);
            }
            if(pFFormRes != NULL){
                Dec_GraphFree( pFFormRes );
            }
            continue;
        }
    }
 
    /*
    printf("Nodes with rewrite: %d\n", ops_rwr);
    printf("Nodes with resub: %d\n", ops_res);
    printf("Nodes with refactor: %d\n", ops_ref);
    printf("Nodes without updates: %d\n", ops_null); 
    Extra_ProgressBarStop( pProgress );
     */
 
// Rewrite
Rwr_ManAddTimeTotal( pManRwr, Abc_Clock() - clkStart );
    pManRwr->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
// Resub
pManRes->timeTotal = Abc_Clock() - clkStart;
    pManRes->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
// Refactor
pManRef->timeTotal = Abc_Clock() - clkStart;
    pManRef->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
    // print statistics
    if ( fVerbose ){
        Abc_ManResubPrint( pManRes );
        Rwr_ManPrintStats( pManRwr );
        Abc_NtkManRefPrintStats_1( pManRef );
    }
    if ( fVeryVerbose )
        Rwr_ScoresReport( pManRwr );
    // delete the managers
    // resub
    Abc_ManResubStop( pManRes );
    Abc_NtkManCutStop( pManCutRes );
    // rewrite
    Rwr_ManStop( pManRwr );
    Cut_ManStop( pManCutRwr );
    pNtk->pManCut = NULL;
    // refactor
    Abc_NtkManCutStop( pManCutRef );
    Abc_NtkManRefStop_1( pManRef );
 
    if ( pManOdc ) Abc_NtkDontCareFree( pManOdc );
 
    // clean the data field
    Abc_NtkForEachObj( pNtk, pNode, i )
        pNode->pData = NULL;
 
    if ( Abc_NtkLatchNum(pNtk) ) {
        Abc_NtkForEachLatch(pNtk, pNode, i)
            pNode->pData = pNode->pNext, pNode->pNext = NULL;
    }
 
    // put the nodes into the DFS order and reassign their IDs
    Abc_NtkReassignIds( pNtk );
//    Abc_AigCheckFaninOrder( pNtk->pManFunc );
 
    // fix the levels
    if ( fUpdateLevel )
        Abc_NtkStopReverseLevels( pNtk );
    else
        Abc_NtkLevel( pNtk );
    // check
    if ( !Abc_NtkCheck( pNtk ) )
    {
        printf( "Abc_NtkOchestraction: The network check has failed.\n" );
        return 0;
    }
s_ResubTime = Abc_Clock() - clkStart;
    return 1;
}

Here is the call graph for this function:

Abc_NtkOrchRand()

int Abc_NtkOrchRand	(	Abc_Ntk_t *	pNtk,
		Vec_Int_t **	pGain_rwr,
		Vec_Int_t **	pGain_res,
		Vec_Int_t **	pGain_ref,
		Vec_Int_t **	DecisionMask,
		char *	DecisionFile,
		int	Rand_Seed,
		int	fUseZeros_rwr,
		int	fUseZeros_ref,
		int	fPlaceEnable,
		int	nCutMax,
		int	nStepsMax,
		int	nLevelsOdc,
		int	fUpdateLevel,
		int	fVerbose,
		int	fVeryVerbose,
		int	nNodeSizeMax,
		int	nConeSizeMax,
		int	fUseDcs )

Definition at line 5355 of file abcOrchestration.c.

{
    extern int           Dec_GraphUpdateNetwork( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, int fUpdateLevel, int nGain );
    ProgressBar * pProgress;
    // For resub
    Abc_ManRes_t * pManRes;
    Abc_ManCut_t * pManCutRes;
    Odc_Man_t * pManOdc = NULL;
    Dec_Graph_t * pFFormRes;
    Vec_Ptr_t * vLeaves;
    // For rewrite
    Cut_Man_t * pManCutRwr;
    Rwr_Man_t * pManRwr;
    Dec_Graph_t * pGraph;
    // For refactor
    Abc_ManRef_t * pManRef;
    Abc_ManCut_t * pManCutRef;
    Dec_Graph_t * pFFormRef;
    Vec_Ptr_t * vFanins;
 
    Abc_Obj_t * pNode;
    FILE *fpt;
    abctime clk, clkStart = Abc_Clock();
    int i, nNodes, nNodes_after, nGain, fCompl;
    int RetValue = 1;
    int ops_rwr = 0;
    int ops_res = 0;
    int ops_ref = 0;
    int ops_null = 0;
    int Valid_Len = 0;
    //Vec_Int_t *Valid_Ops;
 
    //clock_t begin= clock();
    assert( Abc_NtkIsStrash(pNtk) );
 
    // cleanup the AIG
    Abc_AigCleanup((Abc_Aig_t *)pNtk->pManFunc);
 
    // start the managers resub
    pManCutRes = Abc_NtkManCutStart( nCutMax, 100000, 100000, 100000 );
    pManRes = Abc_ManResubStart( nCutMax, ABC_RS_DIV1_MAX );
    if ( nLevelsOdc > 0 )
    pManOdc = Abc_NtkDontCareAlloc( nCutMax, nLevelsOdc, fVerbose, fVeryVerbose );
    // start the managers refactor
    pManCutRef = Abc_NtkManCutStart( nNodeSizeMax, nConeSizeMax, 2, 1000 );
    pManRef = Abc_NtkManRefStart_1( nNodeSizeMax, nConeSizeMax, fUseDcs, fVerbose );
    pManRef->vLeaves   = Abc_NtkManCutReadCutLarge( pManCutRef );
    // start the managers rewrite
    pManRwr = Rwr_ManStart( 0 );
    if ( pManRwr == NULL )
        return 0;
 
    // compute the reverse levels if level update is requested
    if ( fUpdateLevel )
        Abc_NtkStartReverseLevels( pNtk, 0 );
 
    // 'Resub only'
    
    if ( Abc_NtkLatchNum(pNtk) ) {
        Abc_NtkForEachLatch(pNtk, pNode, i)
            pNode->pNext = (Abc_Obj_t *)pNode->pData;
    }
    
    // cut manager for rewrite
clk = Abc_Clock();
    pManCutRwr = Abc_NtkStartCutManForRewrite( pNtk );
Rwr_ManAddTimeCuts( pManRwr, Abc_Clock() - clk );
    pNtk->pManCut = pManCutRwr;
 
    if ( fVeryVerbose )
        Rwr_ScoresClean( pManRwr );
 
  // resynthesize each node once
  // resub
    pManRes->nNodesBeg = Abc_NtkNodeNum(pNtk);
  // rewrite
    pManRwr->nNodesBeg = Abc_NtkNodeNum(pNtk);
  // refactor
    pManRef->nNodesBeg = Abc_NtkNodeNum(pNtk);
 
//clock_t resyn_end=clock();
//double resyn_time_spent = (double)(resyn_end-begin)/CLOCKS_PER_SEC;
//printf("time %f\n", resyn_time_spent);
    nNodes = Abc_NtkObjNumMax(pNtk);
    //printf("nNodes: %d\n", nNodes);
    //for(int i=0; i < nNodes; i++){printf("mask check: %d\n", (*DecisionMask)->pArray[i]);}
    //printf("mask size:%d", (**DecisionMask).nSize);
    if (pGain_res) *pGain_res = Vec_IntAlloc(1);
    if (pGain_ref) *pGain_ref = Vec_IntAlloc(1);
    if (pGain_rwr) *pGain_rwr = Vec_IntAlloc(1);
    Vec_Int_t  *Valid_Ops = Vec_IntAlloc(1);
 
    pProgress = Extra_ProgressBarStart( stdout, nNodes );
    fpt = fopen(DecisionFile, "w");
 
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        //printf("Ochestration id: %d\n", pNode->Id);
        int iterNode = pNode->Id;
        Extra_ProgressBarUpdate( pProgress, i, NULL );
        // skip the constant node
//        if ( Abc_NodeIsConst(pNode) )
//            continue;
        // stop if all nodes have been tried once
        if ( i >= nNodes )
            break;
        // skip persistant nodes
        if ( Abc_NodeIsPersistant(pNode) )
        {
            //fprintf(fpt, "%d, %s, %d\n", pNode->Id, "None" , -99);
            Vec_IntPush((*pGain_res), -99);
            Vec_IntPush((*pGain_ref), -99);
            Vec_IntPush((*pGain_rwr), -99);
            continue;
        } 
        // skip the nodes with many fanouts
        if ( Abc_ObjFanoutNum(pNode) > 1000 )
        {
            //fprintf(fpt, "%d, %s, %d\n", pNode->Id,"None", -99);
            Vec_IntPush((*pGain_res), -99);
            Vec_IntPush((*pGain_ref), -99);
            Vec_IntPush((*pGain_rwr), -99);
            continue;
        }
clk = Abc_Clock();
 
// Generate random operation
// check transformability of all three operations
    Vec_IntPush( (Valid_Ops), -1);
    nGain = Rwr_NodeRewrite( pManRwr, pManCutRwr, pNode, fUpdateLevel, fUseZeros_rwr, fPlaceEnable );
    Vec_IntPush( (*pGain_rwr), nGain);
    if (nGain > 0 || (nGain == 0 && fUseZeros_rwr))
    {
        Vec_IntPush( (Valid_Ops), 0);
    }
    vLeaves = Abc_NodeFindCut( pManCutRes, pNode, 0 ); 
    pManRes->timeCut += Abc_Clock() - clk;
    if ( pManOdc )
    {
clk = Abc_Clock();
        Abc_NtkDontCareClear( pManOdc );
        Abc_NtkDontCareCompute( pManOdc, pNode, vLeaves, pManRes->pCareSet );
pManRes->timeTruth += Abc_Clock() - clk;
    }
clk = Abc_Clock();
    pFFormRes = Abc_ManResubEval( pManRes, pNode, vLeaves, nStepsMax, fUpdateLevel, fVerbose );
pManRes->timeRes += Abc_Clock() - clk;
    Vec_IntPush((*pGain_res), pManRes->nLastGain);
    if (pManRes->nLastGain > 0)
    {
        if ( pFFormRes != NULL ){
        Vec_IntPush( (Valid_Ops), 1);
        }
    }
    
    vFanins = Abc_NodeFindCut( pManCutRef, pNode, fUseDcs );
pManRef->timeCut += Abc_Clock() - clk;
clk = Abc_Clock();
    pFFormRef = Abc_NodeRefactor_1( pManRef, pNode, vFanins, fUpdateLevel, fUseZeros_ref, fUseDcs, fVerbose );
pManRef->timeRes += Abc_Clock() - clk;
 
    Vec_IntPush((*pGain_ref), pManRef->nLastGain);
    if (pManRef->nLastGain > 0 || (pManRef->nLastGain ==0 && fUseZeros_ref))
    {
         if ( pFFormRef != NULL ){
             Vec_IntPush( (Valid_Ops), 2);
         }
    }
    Valid_Len = (Valid_Ops)->nSize;
    //printf("The length of valid operations: %d\n", Valid_Len);
 
//Pick a random operations from valid ones
if (Rand_Seed == -1)
{
    srand(time(NULL));
}
else
{
    srand(Rand_Seed);
}
 
int r = rand() % Valid_Len;
 
    if ((Valid_Ops)->pArray[r] == -1){ 
        (*DecisionMask)->pArray[iterNode] = -1;
        ops_null++;
    Vec_IntZero(Valid_Ops); // reset updates
        continue;
    }
    else if ((Valid_Ops->pArray[r]) == 0){
    // apply rewrite
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
        if ( fCompl ) Dec_GraphComplement( pGraph );
        (*DecisionMask)->pArray[iterNode] = 0;
        ops_rwr++;
    Vec_IntZero(Valid_Ops); // reset updates
        continue;
    }
    else if ((Valid_Ops->pArray[r] == 1)){
    // apply res
        pManRes->nTotalGain += pManRes->nLastGain;
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pFFormRes, fUpdateLevel, pManRes->nLastGain );
pManRes->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRes );
        (*DecisionMask)->pArray[iterNode] = 1;
        ops_res++;
    Vec_IntZero(Valid_Ops); // reset updates
        continue;
    }
    else if ((Valid_Ops->pArray[r] == 2)){
clk = Abc_Clock();
        if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef, fUpdateLevel, pManRef->nLastGain ) )
                 {
                     Dec_GraphFree( pFFormRef );
                     RetValue = -1;
                     break;
                 }
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRef );
        (*DecisionMask)->pArray[iterNode] = 2;
        ops_ref++;
    Vec_IntZero(Valid_Ops); // reset updates
        continue;
      }
    }
    //fwrite((**DecisionMask).pArray, sizeof(int), sizeof((**DecisionMask).pArray), fpt);
    for (int i = 0; i < (nNodes); i++){
        fprintf(fpt, "%d\n", (*DecisionMask)->pArray[i]);}
    fclose(fpt);
/*
    printf("size of vector %d\n", Valid_Len);
    printf("Nodes with rewrite: %d\n", ops_rwr);
    printf("Nodes with resub: %d\n", ops_res);
    printf("Nodes with refactor: %d\n", ops_ref);
    printf("Nodes without updates: %d\n", ops_null);
*/
    Extra_ProgressBarStop( pProgress );
// Rewrite
Rwr_ManAddTimeTotal( pManRwr, Abc_Clock() - clkStart );
    pManRwr->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
// Resub
pManRes->timeTotal = Abc_Clock() - clkStart;
    pManRes->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
// Refactor
pManRef->timeTotal = Abc_Clock() - clkStart;
    pManRef->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
    // print statistics
    if ( fVerbose ){
        Abc_ManResubPrint( pManRes );
        Rwr_ManPrintStats( pManRwr );
        Abc_NtkManRefPrintStats_1( pManRef );
    }
    if ( fVeryVerbose )
        Rwr_ScoresReport( pManRwr );
    // delete the managers
    // resub
    Abc_ManResubStop( pManRes );
    Abc_NtkManCutStop( pManCutRes );
    // rewrite
    Rwr_ManStop( pManRwr );
    Cut_ManStop( pManCutRwr );
    pNtk->pManCut = NULL;
    // refactor
    Abc_NtkManCutStop( pManCutRef );
    Abc_NtkManRefStop_1( pManRef );
 
    if ( pManOdc ) Abc_NtkDontCareFree( pManOdc );
 
    // clean the data field
    Abc_NtkForEachObj( pNtk, pNode, i )
        pNode->pData = NULL;
 
    if ( Abc_NtkLatchNum(pNtk) ) {
        Abc_NtkForEachLatch(pNtk, pNode, i)
            pNode->pData = pNode->pNext, pNode->pNext = NULL;
    }
 
    // put the nodes into the DFS order and reassign their IDs
    Abc_NtkReassignIds( pNtk );
//    Abc_AigCheckFaninOrder( pNtk->pManFunc );
 
    // fix the levels
    if ( fUpdateLevel )
        Abc_NtkStopReverseLevels( pNtk );
    else
        Abc_NtkLevel( pNtk );
    // check
    if ( !Abc_NtkCheck( pNtk ) )
    {
        printf( "Abc_NtkOchestraction: The network check has failed.\n" );
        return 0;
    }
    nNodes_after = Abc_NtkObjNumMax(pNtk);
    //printf("nNodes after optimization: %d\n", nNodes_after);
//s_ResubTime = Abc_Clock() - clkStart;
//clock_t end=clock();
//double time_spent = (double)(end-begin)/CLOCKS_PER_SEC;
//printf("time %f\n", time_spent);
    return 1;
}

Here is the call graph for this function:

Abc_NtkOrchSA()

int Abc_NtkOrchSA	(	Abc_Ntk_t *	pNtk,
		Vec_Int_t **	pGain_rwr,
		Vec_Int_t **	pGain_res,
		Vec_Int_t **	pGain_ref,
		Vec_Int_t **	PolicyList,
		char *	DecisionFile,
		int	fUseZeros_rwr,
		int	fUseZeros_ref,
		int	fPlaceEnable,
		int	nCutMax,
		int	nStepsMax,
		int	nLevelsOdc,
		int	fUpdateLevel,
		int	fVerbose,
		int	fVeryVerbose,
		int	nNodeSizeMax,
		int	nConeSizeMax,
		int	fUseDcs )

Definition at line 2666 of file abcOrchestration.c.

{
    ProgressBar * pProgress;
    // For resub
    Abc_ManRes_t * pManRes;
    Abc_ManCut_t * pManCutRes;
    Odc_Man_t * pManOdc = NULL;
    Dec_Graph_t * pFFormRes;
    Vec_Ptr_t * vLeaves;
    // For rewrite
    Cut_Man_t * pManCutRwr;
    Rwr_Man_t * pManRwr;
    Dec_Graph_t * pGraph;
    // For refactor
    Abc_ManRef_t * pManRef;
    Abc_ManCut_t * pManCutRef;
    Dec_Graph_t * pFFormRef;
    Vec_Ptr_t * vFanins;
    Vec_Int_t * DecisionMask = Vec_IntAlloc(1);
 
    Abc_Obj_t * pNode;
    FILE *fpt;
    abctime clk, clkStart = Abc_Clock();
    abctime s_ResubTime;
    int i, nNodes, nGain, fCompl, RetValue = 1;
    int ops_rwr = 0;
    int ops_res = 0;
    int ops_ref = 0;
    int ops_null = 0;
    int sOpsOrder = 0;
    assert( Abc_NtkIsStrash(pNtk) );
 
    // cleanup the AIG
    Abc_AigCleanup((Abc_Aig_t *)pNtk->pManFunc);
 
    // start the managers resub
    pManCutRes = Abc_NtkManCutStart( nCutMax, 100000, 100000, 100000 );
    pManRes = Abc_ManResubStart( nCutMax, ABC_RS_DIV1_MAX );
    if ( nLevelsOdc > 0 )
    pManOdc = Abc_NtkDontCareAlloc( nCutMax, nLevelsOdc, fVerbose, fVeryVerbose );
    // start the managers refactor
    pManCutRef = Abc_NtkManCutStart( nNodeSizeMax, nConeSizeMax, 2, 1000 );
    pManRef = Abc_NtkManRefStart_1( nNodeSizeMax, nConeSizeMax, fUseDcs, fVerbose );
    pManRef->vLeaves   = Abc_NtkManCutReadCutLarge( pManCutRef );
    // start the managers rewrite
    pManRwr = Rwr_ManStart( 0 );
    if ( pManRwr == NULL )
        return 0;
 
    // compute the reverse levels if level update is requested
    if ( fUpdateLevel )
        Abc_NtkStartReverseLevels( pNtk, 0 );
    if ( Abc_NtkLatchNum(pNtk) ) {
        Abc_NtkForEachLatch(pNtk, pNode, i)
            pNode->pNext = (Abc_Obj_t *)pNode->pData;
    }
clk = Abc_Clock();
    pManCutRwr = Abc_NtkStartCutManForRewrite( pNtk );
Rwr_ManAddTimeCuts( pManRwr, Abc_Clock() - clk );
    pNtk->pManCut = pManCutRwr;
 
    if ( fVeryVerbose )
        Rwr_ScoresClean( pManRwr );
 
    pManRes->nNodesBeg = Abc_NtkNodeNum(pNtk);
    pManRwr->nNodesBeg = Abc_NtkNodeNum(pNtk);
    pManRef->nNodesBeg = Abc_NtkNodeNum(pNtk);
 
    nNodes = Abc_NtkObjNumMax(pNtk);
    //printf("nNodes: %d\n", nNodes);
    if (pGain_res) *pGain_res = Vec_IntAlloc(1);
    if (pGain_ref) *pGain_ref = Vec_IntAlloc(1);
    if (pGain_rwr) *pGain_rwr = Vec_IntAlloc(1);
    for(int i=0; i < nNodes; i++){Vec_IntPush(DecisionMask, atoi("-1"));}
 
    pProgress = Extra_ProgressBarStart( stdout, nNodes );
    fpt = fopen(DecisionFile, "w");
 
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        int iterNode = pNode->Id;
        Extra_ProgressBarUpdate( pProgress, i, NULL );
        if ( Abc_NodeIsPersistant(pNode) )
        {
            //fprintf(fpt, "%d, %d\n", iterNode, -99);
            Vec_IntPush((*pGain_res), -99);
            Vec_IntPush((*pGain_ref), -99);
            Vec_IntPush((*pGain_rwr), -99);
            continue;
        }
        if ( Abc_ObjFanoutNum(pNode) > 1000 )
        {
            //fprintf(fpt, "%d, %d\n", iterNode, -99);
            Vec_IntPush((*pGain_res), -99);
            Vec_IntPush((*pGain_ref), -99);
            Vec_IntPush((*pGain_rwr), -99);
            continue;
        }
        if ( i >= nNodes )
            break;
 
//refactor
clk = Abc_Clock();
        vFanins = Abc_NodeFindCut( pManCutRef, pNode, fUseDcs );
pManRef->timeCut += Abc_Clock() - clk;
clk = Abc_Clock();
        pFFormRef = Abc_NodeRefactor_1( pManRef, pNode, vFanins, fUpdateLevel, fUseZeros_ref, fUseDcs, fVerbose );
pManRef->timeRes += Abc_Clock() - clk;
        Vec_IntPush((*pGain_ref), pManRef->nLastGain);
//resub
        vLeaves = Abc_NodeFindCut( pManCutRes, pNode, 0 );
pManRes->timeCut += Abc_Clock() - clk;
        if ( pManOdc )
        {
clk = Abc_Clock();
            Abc_NtkDontCareClear( pManOdc );
            Abc_NtkDontCareCompute( pManOdc, pNode, vLeaves, pManRes->pCareSet );
pManRes->timeTruth += Abc_Clock() - clk;
        }
clk = Abc_Clock();
        pFFormRes = Abc_ManResubEval( pManRes, pNode, vLeaves, nStepsMax, fUpdateLevel, fVerbose );
pManRes->timeRes += Abc_Clock() - clk;
        Vec_IntPush((*pGain_res), pManRes->nLastGain);
//rewrite
        nGain = Rwr_NodeRewrite( pManRwr, pManCutRwr, pNode, fUpdateLevel, fUseZeros_rwr, fPlaceEnable );
        Vec_IntPush( (*pGain_rwr), nGain);
        //fprintf(fpt, "%d, %s, %d, %s, %d, %s, %d\n", pNode->Id, "Oches_Res", pManRes->nLastGain, "Oches_Ref", pManRef->nLastGain, "Oches_Rwr", nGain);
 
      if ((**PolicyList).pArray[iterNode] == 0){sOpsOrder = 0;}
      if ((**PolicyList).pArray[iterNode] == 1){sOpsOrder = 1;}
      if ((**PolicyList).pArray[iterNode] == 2){sOpsOrder = 2;}
      if ((**PolicyList).pArray[iterNode] == 3){sOpsOrder = 3;}
      if ((**PolicyList).pArray[iterNode] == 4){sOpsOrder = 4;}
      if ((**PolicyList).pArray[iterNode] == 5){sOpsOrder = 5;}
 
     if ( sOpsOrder == 0)
      {
        //printf("policy orchestration with o1.");
        if (nGain > 0 || (nGain == 0 && fUseZeros_rwr))
        {
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
        if ( fCompl ) Dec_GraphComplement( pGraph );
        ops_rwr++;
        //fprintf(fpt, "%d, %d\n", iterNode, 0);
        (DecisionMask)->pArray[iterNode] = 0;
        continue;
        }
 
        if (pManRes->nLastGain > 0)
        {
 
        if ( pFFormRes == NULL )
            continue;
        pManRes->nTotalGain += pManRes->nLastGain;
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pFFormRes, fUpdateLevel, pManRes->nLastGain );
pManRes->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRes );
        ops_res++;
        //fprintf(fpt, "%d, %d\n", iterNode, 1);
        (DecisionMask)->pArray[iterNode] = 2;
        continue;
        }
 
        if (pManRef->nLastGain > 0 || (pManRef->nLastGain ==0 && fUseZeros_ref))
        {
        if ( pFFormRef == NULL )
            continue;
clk = Abc_Clock();
        if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef, fUpdateLevel, pManRef->nLastGain ) )
                 {
                     Dec_GraphFree( pFFormRef );
                     RetValue = -1;
                     break;
                 }
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRef );
        ops_ref++;
        //fprintf(fpt, "%d, %d\n", iterNode, 2);
        (DecisionMask)->pArray[iterNode] = 3;
        continue;
        }
        if (! (nGain > 0 || pManRef->nLastGain > 0 || pManRes->nLastGain > 0 || (nGain == 0 && fUseZeros_rwr)))
        {
        ops_null++;
        //fprintf(fpt, "%d, %d\n", iterNode, -1);
        continue;
        }
      }
 
      if ( sOpsOrder == 1)
      {
        //printf("policy orchestration with o2.");
        if (nGain > 0 || (nGain == 0 && fUseZeros_rwr))
        {
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
        if ( fCompl ) Dec_GraphComplement( pGraph );
        ops_rwr++;
        //fprintf(fpt, "%d, %d\n", iterNode, 0);
        (DecisionMask)->pArray[iterNode] = 0;
        continue;
        }
 
        if (pManRef->nLastGain > 0 || (pManRef->nLastGain ==0 && fUseZeros_ref))
        {
        if ( pFFormRef == NULL )
            continue;
clk = Abc_Clock();
        if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef, fUpdateLevel, pManRef->nLastGain ) )
                 {
                     Dec_GraphFree( pFFormRef );
                     RetValue = -1;
                     break;
                 }
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRef );
        ops_ref++;
        //fprintf(fpt, "%d, %d\n", iterNode, 2);
        (DecisionMask)->pArray[iterNode] = 3;
        continue;
        }
 
        if (pManRes->nLastGain > 0)
        {
        if ( pFFormRes == NULL )
            continue;
        pManRes->nTotalGain += pManRes->nLastGain;
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pFFormRes, fUpdateLevel, pManRes->nLastGain );
pManRes->timeNtk += Abc_Clock() - clk; 
        Dec_GraphFree( pFFormRes );
        ops_res++;
        //fprintf(fpt, "%d, %d\n", iterNode, 1);
        (DecisionMask)->pArray[iterNode] = 2;
        continue;
        }
        if (! (nGain > 0 || pManRef->nLastGain > 0 || pManRes->nLastGain > 0 || (nGain == 0 && fUseZeros_rwr)))
        {
        ops_null++;
        //fprintf(fpt, "%d, %d\n", iterNode, -1);
        continue;
        }
      } 
      
      if ( sOpsOrder == 2)
      {
        //printf("policy orchestration with o3.");
        if (pManRes->nLastGain > 0)
        {
        if ( pFFormRes == NULL )
            continue;
        pManRes->nTotalGain += pManRes->nLastGain;
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pFFormRes, fUpdateLevel, pManRes->nLastGain );
pManRes->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRes );
        ops_res++;
        //fprintf(fpt, "%d, %d\n", iterNode, 1);
        (DecisionMask)->pArray[iterNode] = 2;
        continue;
        }
 
        if (nGain > 0 || (nGain == 0 && fUseZeros_rwr))
        {
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
        if ( fCompl ) Dec_GraphComplement( pGraph );
        ops_rwr++;
        //fprintf(fpt, "%d, %d\n", iterNode, 0);
        (DecisionMask)->pArray[iterNode] = 0;
        continue;
        }
 
        if (pManRef->nLastGain > 0 || (pManRef->nLastGain ==0 && fUseZeros_ref))
        {
        if ( pFFormRef == NULL )
            continue;
clk = Abc_Clock();
        if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef, fUpdateLevel, pManRef->nLastGain ) )
                 {
                     Dec_GraphFree( pFFormRef );
                     RetValue = -1;
                     break;
                 }
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRef );
        ops_ref++;
        //fprintf(fpt, "%d, %d\n", iterNode, 2);
        (DecisionMask)->pArray[iterNode] = 3;
        continue;
        }
        if (! (nGain > 0 || pManRef->nLastGain > 0 || pManRes->nLastGain > 0 || (nGain == 0 && fUseZeros_rwr)))
        {
        ops_null++;
        //fprintf(fpt, "%d, %d\n", iterNode, -1);
        continue;
        }
      }
 
      if ( sOpsOrder == 3)
      {
        //printf("policy orchestration with o4.");
        if (pManRes->nLastGain > 0)
        {
        if ( pFFormRes == NULL )
            continue;
        pManRes->nTotalGain += pManRes->nLastGain;
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pFFormRes, fUpdateLevel, pManRes->nLastGain );
pManRes->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRes );
        ops_res++;
        //fprintf(fpt, "%d, %d\n", iterNode, 1);
        (DecisionMask)->pArray[iterNode] = 2;
        continue;
        }
 
        if (pManRef->nLastGain > 0 || (pManRef->nLastGain ==0 && fUseZeros_ref))
        {
       if ( pFFormRef == NULL )
            continue;
clk = Abc_Clock();
        if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef, fUpdateLevel, pManRef->nLastGain ) )
                 {
                     Dec_GraphFree( pFFormRef );
                     RetValue = -1;
                     break;
                 }
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRef );
        ops_ref++;
        //fprintf(fpt, "%d, %d\n", iterNode, 2);
        (DecisionMask)->pArray[iterNode] = 3;
        continue;
        }
 
        if (nGain > 0 || (nGain == 0 && fUseZeros_rwr))
        {
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
        if ( fCompl ) Dec_GraphComplement( pGraph );
        ops_rwr++;
        //fprintf(fpt, "%d, %d\n", iterNode, 0);
        (DecisionMask)->pArray[iterNode] = 0;
        continue;
        }
 
        if (! (nGain > 0 || pManRef->nLastGain > 0 || pManRes->nLastGain > 0 || (nGain == 0 && fUseZeros_rwr)))
        {
        ops_null++;
        //fprintf(fpt, "%d, %d\n", iterNode, -1);
        continue;
        }
      }
 
      if ( sOpsOrder == 4)
      {
        //printf("policy orchestration with o5.");
       if (pManRef->nLastGain > 0 || (pManRef->nLastGain ==0 && fUseZeros_ref))
        {
        if ( pFFormRef == NULL )
            continue;
clk = Abc_Clock();
        if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef, fUpdateLevel, pManRef->nLastGain ) )
                 {
                     Dec_GraphFree( pFFormRef );
                     RetValue = -1;
                     break;
                 }
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRef );
        ops_ref++;
        //fprintf(fpt, "%d, %d\n", iterNode, 2);
        (DecisionMask)->pArray[iterNode] = 3;
        continue;
        }
 
        if (nGain > 0 || (nGain == 0 && fUseZeros_rwr))
        {
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
        if ( fCompl ) Dec_GraphComplement( pGraph );
        ops_rwr++;
        //fprintf(fpt, "%d, %d\n", iterNode, 0);
        (DecisionMask)->pArray[iterNode] = 0;
        continue;
        }
 
        if (pManRes->nLastGain > 0)
        {
        if ( pFFormRes == NULL )
            continue;
        pManRes->nTotalGain += pManRes->nLastGain;
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pFFormRes, fUpdateLevel, pManRes->nLastGain );
pManRes->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRes );
        ops_res++;
        //fprintf(fpt, "%d, %d\n", iterNode, 1);
        (DecisionMask)->pArray[iterNode] = 2;
        continue;
        }
       if (! (nGain > 0 || pManRef->nLastGain > 0 || pManRes->nLastGain > 0 || (nGain == 0 && fUseZeros_rwr)))
        {
        ops_null++;
        //fprintf(fpt, "%d, %d\n", iterNode, -1);
        continue;
        }
      }
 
      if ( sOpsOrder == 5)
      {
        //printf("policy orchestration with o6.");
        if (pManRef->nLastGain > 0 || (pManRef->nLastGain ==0 && fUseZeros_ref))
        {
        if ( pFFormRef == NULL )
            continue;
clk = Abc_Clock();
        if ( !Dec_GraphUpdateNetwork( pNode, pFFormRef, fUpdateLevel, pManRef->nLastGain ) )
                 {
                     Dec_GraphFree( pFFormRef );
                     RetValue = -1;
                     break;
                 }
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRef );
        ops_ref++;
        //fprintf(fpt, "%d, %d\n", iterNode, 2);
        (DecisionMask)->pArray[iterNode] = 3;
        continue;
        }
 
        if (pManRes->nLastGain > 0)
        {
        if ( pFFormRes == NULL )
            continue;
        pManRes->nTotalGain += pManRes->nLastGain;
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pFFormRes, fUpdateLevel, pManRes->nLastGain );
pManRes->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFFormRes );
        ops_res++;
        //fprintf(fpt, "%d, %d\n", iterNode, 1);
        (DecisionMask)->pArray[iterNode] = 2;
        continue;
        }
 
        if (nGain > 0 || (nGain == 0 && fUseZeros_rwr))
        {
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
Rwr_ManAddTimeUpdate( pManRwr, Abc_Clock() - clk );
        if ( fCompl ) Dec_GraphComplement( pGraph );
        ops_rwr++;
        //fprintf(fpt, "%d, %d\n", iterNode, 0);
        (DecisionMask)->pArray[iterNode] = 0;
        continue;
        }
        if (! (nGain > 0 || pManRef->nLastGain > 0 || pManRes->nLastGain > 0 || (nGain == 0 && fUseZeros_rwr)))
        {
        ops_null++;
        //fprintf(fpt, "%d, %d\n", iterNode, -1);
        continue;
        }
      }
 
    }
    for (int i=0; i<nNodes; i++){fprintf(fpt, "%d\n", (DecisionMask)->pArray[i]);}
    fclose(fpt);
    /*
    printf("size of vector %d\n", (**pGain_res).nSize);
    printf("Nodes with rewrite: %d\n", ops_rwr);
    printf("Nodes with resub: %d\n", ops_res);
    printf("Nodes with refactor: %d\n", ops_ref);
    printf("Nodes without updates: %d\n", ops_null);
    */
    Extra_ProgressBarStop( pProgress );
Rwr_ManAddTimeTotal( pManRwr, Abc_Clock() - clkStart );
    pManRwr->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
pManRes->timeTotal = Abc_Clock() - clkStart;
    pManRes->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
pManRef->timeTotal = Abc_Clock() - clkStart;
    pManRef->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
    if ( fVerbose ){
        Abc_ManResubPrint( pManRes );
        Rwr_ManPrintStats( pManRwr );
        Abc_NtkManRefPrintStats_1( pManRef );
    }
    if ( fVeryVerbose )
        Rwr_ScoresReport( pManRwr );
 
    Abc_ManResubStop( pManRes );
    Abc_NtkManCutStop( pManCutRes );
 
    Rwr_ManStop( pManRwr );
    Cut_ManStop( pManCutRwr );
    pNtk->pManCut = NULL;
 
   Abc_NtkManCutStop( pManCutRef );
    Abc_NtkManRefStop_1( pManRef );
 
    if ( pManOdc ) Abc_NtkDontCareFree( pManOdc );
 
    Abc_NtkForEachObj( pNtk, pNode, i )
        pNode->pData = NULL;
 
    if ( Abc_NtkLatchNum(pNtk) ) {
        Abc_NtkForEachLatch(pNtk, pNode, i)
            pNode->pData = pNode->pNext, pNode->pNext = NULL;
    }
    Abc_NtkReassignIds( pNtk );
    if ( fUpdateLevel )
        Abc_NtkStopReverseLevels( pNtk );
    else
        Abc_NtkLevel( pNtk );
    if ( !Abc_NtkCheck( pNtk ) )
    {
        printf( "Abc_NtkOchestraction: The network check has failed.\n" );
        return 0;
    }
s_ResubTime = Abc_Clock() - clkStart;
    return 1;
}

Here is the call graph for this function:

Abc_NtkRefactor3()

int Abc_NtkRefactor3	(	Abc_Ntk_t *	pNtk,
		Vec_Int_t **	pGain_ref,
		int	nNodeSizeMax,
		int	nConeSizeMax,
		int	fUpdateLevel,
		int	fUseZeros,
		int	fUseDcs,
		int	fVerbose )

Definition at line 471 of file abcOrchestration.c.

{
    ProgressBar * pProgress;
    Abc_ManRef_t * pManRef;
    Abc_ManCut_t * pManCut;
    Dec_Graph_t * pFForm;
    Vec_Ptr_t * vFanins;
    Abc_Obj_t * pNode;
    FILE *fpt;
    abctime clk, clkStart = Abc_Clock();
    int i, nNodes, RetValue = 1;
 
    assert( Abc_NtkIsStrash(pNtk) );
    Abc_AigCleanup((Abc_Aig_t *)pNtk->pManFunc);
    pManCut = Abc_NtkManCutStart( nNodeSizeMax, nConeSizeMax, 2, 1000 );
    pManRef = Abc_NtkManRefStart_1( nNodeSizeMax, nConeSizeMax, fUseDcs, fVerbose );
    pManRef->vLeaves   = Abc_NtkManCutReadCutLarge( pManCut );
    if ( fUpdateLevel )
        Abc_NtkStartReverseLevels( pNtk, 0 );
    pManRef->nNodesBeg = Abc_NtkNodeNum(pNtk);
    nNodes = Abc_NtkObjNumMax(pNtk);
    //printf("nNodes: %d\n", nNodes);
    if (pGain_ref) *pGain_ref = Vec_IntAlloc(1);
 
    pProgress = Extra_ProgressBarStart( stdout, nNodes );
    fpt = fopen("refactor_id_nGain.csv", "w");
 
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        //printf("Refactor3 Id: %d\n", pNode->Id);
        Extra_ProgressBarUpdate( pProgress, i, NULL );
        if ( Abc_NodeIsPersistant(pNode) )
            continue;
        if ( Abc_ObjFanoutNum(pNode) > 1000 )
            continue;
        if ( i >= nNodes )
            break;
clk = Abc_Clock();
        vFanins = Abc_NodeFindCut( pManCut, pNode, fUseDcs );
pManRef->timeCut += Abc_Clock() - clk;
clk = Abc_Clock();
        pFForm = Abc_NodeRefactor_1( pManRef, pNode, vFanins, fUpdateLevel, fUseZeros, fUseDcs, fVerbose );
pManRef->timeRes += Abc_Clock() - clk;
        //printf("nLastGain3: %d\n", pManRef->nLastGain);
        fprintf(fpt, "%d, %d\n", pNode->Id, pManRef->nLastGain);
        Vec_IntPush((*pGain_ref), pManRef->nLastGain);
 
        if ( pFForm == NULL )
            continue;
clk = Abc_Clock();
 
/*
        if ( !Dec_GraphUpdateNetwork( pNode, pFForm, fUpdateLevel, pManRef->nLastGain ) )
        {
            Dec_GraphFree( pFForm );
            RetValue = -1;
            break;
        }
*/
 
pManRef->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFForm );
    }
    fclose(fpt);
    printf("size of vector: %d\n", (**pGain_ref).nSize);
    //printf("nGain in vector: %d\n", (**pGain_ref).pArray[20]);
    Extra_ProgressBarStop( pProgress );
pManRef->timeTotal = Abc_Clock() - clkStart;
    pManRef->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
    if ( fVerbose )
        Abc_NtkManRefPrintStats_1( pManRef );
    Abc_NtkManCutStop( pManCut );
    Abc_NtkManRefStop_1( pManRef );
    Abc_NtkReassignIds( pNtk );
    if ( RetValue != -1 )
    {
        if ( fUpdateLevel )
            Abc_NtkStopReverseLevels( pNtk );
        else
            Abc_NtkLevel( pNtk );
        if ( !Abc_NtkCheck( pNtk ) )
        {
            printf( "Abc_NtkRefactor: The network check has failed.\n" );
            return 0;
        }
    }
    return RetValue;
}

Here is the call graph for this function:

Abc_NtkResubstitute3()

int Abc_NtkResubstitute3	(	Abc_Ntk_t *	pNtk,
		Vec_Int_t **	pGain_res,
		int	nCutMax,
		int	nStepsMax,
		int	nLevelsOdc,
		int	fUpdateLevel,
		int	fVerbose,
		int	fVeryVerbose )

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

Synopsis [Performs incremental resynthesis of the AIG.]

Description []

SideEffects []

SeeAlso []

Definition at line 572 of file abcOrchestration.c.

{
    ProgressBar * pProgress;
    Abc_ManRes_t * pManRes;
    Abc_ManCut_t * pManCut;
    Odc_Man_t * pManOdc = NULL;
    Dec_Graph_t * pFForm;
    Vec_Ptr_t * vLeaves;
    Abc_Obj_t * pNode;
    FILE *fpt;
    abctime clk, clkStart = Abc_Clock();
    abctime s_ResubTime;
    int i, nNodes;
 
    assert( Abc_NtkIsStrash(pNtk) );
 
    // cleanup the AIG
    Abc_AigCleanup((Abc_Aig_t *)pNtk->pManFunc);
    // start the managers
    pManCut = Abc_NtkManCutStart( nCutMax, 100000, 100000, 100000 );
    pManRes = Abc_ManResubStart( nCutMax, ABC_RS_DIV1_MAX );
    if ( nLevelsOdc > 0 )
    pManOdc = Abc_NtkDontCareAlloc( nCutMax, nLevelsOdc, fVerbose, fVeryVerbose );
 
    // compute the reverse levels if level update is requested
    if ( fUpdateLevel )
        Abc_NtkStartReverseLevels( pNtk, 0 );
 
    if ( Abc_NtkLatchNum(pNtk) ) {
        Abc_NtkForEachLatch(pNtk, pNode, i)
            pNode->pNext = (Abc_Obj_t *)pNode->pData;
    }
 
    // resynthesize each node once
    pManRes->nNodesBeg = Abc_NtkNodeNum(pNtk);
    nNodes = Abc_NtkObjNumMax(pNtk);
    //printf("nNodes: %d\n", nNodes);
    if (pGain_res) *pGain_res = Vec_IntAlloc(1);
 
    pProgress = Extra_ProgressBarStart( stdout, nNodes );
    fpt = fopen("resub_id_nGain.csv", "w");
 
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        //printf("resub id: %d\n", pNode->Id);
        Extra_ProgressBarUpdate( pProgress, i, NULL );
        // skip the constant node
//        if ( Abc_NodeIsConst(pNode) )
//            continue;
        // skip persistant nodes
        if ( Abc_NodeIsPersistant(pNode) )
        {
            fprintf(fpt, "%d, %d\n", pNode->Id, -99);
            Vec_IntPush((*pGain_res), -99);
            continue;
        } 
        // skip the nodes with many fanouts
        if ( Abc_ObjFanoutNum(pNode) > 1000 )
        {
            fprintf(fpt, "%d, %d\n", pNode->Id, -99);
            Vec_IntPush((*pGain_res), -99);
            continue;
        }
        // stop if all nodes have been tried once
        if ( i >= nNodes )
            break;
 
        // compute a reconvergence-driven cut
clk = Abc_Clock();
        vLeaves = Abc_NodeFindCut( pManCut, pNode, 0 );
//        vLeaves = Abc_CutFactorLarge( pNode, nCutMax );
pManRes->timeCut += Abc_Clock() - clk;
/*
        if ( fVerbose && vLeaves )
        printf( "Node %6d : Leaves = %3d. Volume = %3d.\n", pNode->Id, Vec_PtrSize(vLeaves), Abc_CutVolumeCheck(pNode, vLeaves) );
        if ( vLeaves == NULL )
            continue;
*/
        // get the don't-cares
        if ( pManOdc )
        {
clk = Abc_Clock();
            Abc_NtkDontCareClear( pManOdc );
            Abc_NtkDontCareCompute( pManOdc, pNode, vLeaves, pManRes->pCareSet );
pManRes->timeTruth += Abc_Clock() - clk;
        }
 
        // evaluate this cut
clk = Abc_Clock();
        pFForm = Abc_ManResubEval( pManRes, pNode, vLeaves, nStepsMax, fUpdateLevel, fVerbose );
//        Vec_PtrFree( vLeaves );
//        Abc_ManResubCleanup( pManRes );
pManRes->timeRes += Abc_Clock() - clk;
        // put nGain in Vector
        //printf("nLastGain3: %d\n", pManRes->nLastGain);
        fprintf(fpt, "%d, %d\n", pNode->Id, pManRes->nLastGain);
        Vec_IntPush((*pGain_res), pManRes->nLastGain);
        // printf("size of vector %d\n", (**pGain).nSize);
        if ( pFForm == NULL )
            continue;
        pManRes->nTotalGain += pManRes->nLastGain;
/*
        if ( pManRes->nLeaves == 4 && pManRes->nMffc == 2 && pManRes->nLastGain == 1 )
        {
            printf( "%6d :  L = %2d. V = %2d. Mffc = %2d. Divs = %3d.   Up = %3d. Un = %3d. B = %3d.\n", 
                   pNode->Id, pManRes->nLeaves, Abc_CutVolumeCheck(pNode, vLeaves), pManRes->nMffc, pManRes->nDivs, 
                   pManRes->vDivs1UP->nSize, pManRes->vDivs1UN->nSize, pManRes->vDivs1B->nSize );
            Abc_ManResubPrintDivs( pManRes, pNode, vLeaves );
        }
*/
 
clk = Abc_Clock();
        //Dec_GraphUpdateNetwork( pNode, pFForm, fUpdateLevel, pManRes->nLastGain );
pManRes->timeNtk += Abc_Clock() - clk;
        Dec_GraphFree( pFForm );
 
    }
    fclose(fpt);
    printf("size of vector %d\n", (**pGain_res).nSize);
    //printf("nGain in vector: %d\n", (**pGain_res).pArray[20]);
    Extra_ProgressBarStop( pProgress );
pManRes->timeTotal = Abc_Clock() - clkStart;
    pManRes->nNodesEnd = Abc_NtkNodeNum(pNtk);
 
    // print statistics
    if ( fVerbose )
    Abc_ManResubPrint( pManRes );
 
    // delete the managers
    Abc_ManResubStop( pManRes );
    Abc_NtkManCutStop( pManCut );
    if ( pManOdc ) Abc_NtkDontCareFree( pManOdc );
 
    // clean the data field
    Abc_NtkForEachObj( pNtk, pNode, i )
        pNode->pData = NULL;
 
    if ( Abc_NtkLatchNum(pNtk) ) {
        Abc_NtkForEachLatch(pNtk, pNode, i)
            pNode->pData = pNode->pNext, pNode->pNext = NULL;
    }
 
    // put the nodes into the DFS order and reassign their IDs
    Abc_NtkReassignIds( pNtk );
//    Abc_AigCheckFaninOrder( pNtk->pManFunc );
    // fix the levels
    if ( fUpdateLevel )
        Abc_NtkStopReverseLevels( pNtk );
    else
        Abc_NtkLevel( pNtk );
    // check
    if ( !Abc_NtkCheck( pNtk ) )
    {
        printf( "Abc_NtkRefactor: The network check has failed.\n" );
        return 0;
    }
s_ResubTime = Abc_Clock() - clkStart;
    return 1;
}

Here is the call graph for this function:

Abc_NtkRewrite3()

int Abc_NtkRewrite3	(	Abc_Ntk_t *	pNtk,
		Vec_Int_t **	pGain_rw,
		int	fUpdateLevel,
		int	fUseZeros,
		int	fVerbose,
		int	fVeryVerbose,
		int	fPlaceEnable )

FUNCTION DEFINITIONS ///.

Function*********************************************************** Rewrite

Definition at line 171 of file abcOrchestration.c.

{
    ProgressBar * pProgress;
    Cut_Man_t * pManCut;
    Rwr_Man_t * pManRwr;
    Abc_Obj_t * pNode;
    FILE *fpt;
    Dec_Graph_t * pGraph;
    int i, nNodes, nGain, fCompl;
    int success = 0;
    int fail = 0;
    abctime clk, clkStart = Abc_Clock();
    assert( Abc_NtkIsStrash(pNtk) );
    Abc_AigCleanup((Abc_Aig_t *)pNtk->pManFunc);
    pManRwr = Rwr_ManStart( 0 );
    if ( pManRwr == NULL )
        return 0;
    if ( fUpdateLevel )
        Abc_NtkStartReverseLevels( pNtk, 0 );
clk = Abc_Clock();
    pManCut = Abc_NtkStartCutManForRewrite( pNtk );
Rwr_ManAddTimeCuts( pManRwr, Abc_Clock() - clk );
    pNtk->pManCut = pManCut;
 
    if ( fVeryVerbose )
        Rwr_ScoresClean( pManRwr );
 
    pManRwr->nNodesBeg = Abc_NtkNodeNum(pNtk);
    nNodes = Abc_NtkObjNumMax(pNtk);
 
    //printf("nNodes: %d\n", nNodes);
    if ( pGain_rw ) *pGain_rw = Vec_IntAlloc(1);
 
    pProgress = Extra_ProgressBarStart( stdout, nNodes );
    fpt = fopen("rewrite_id_nGain.csv", "w");
    Abc_NtkForEachNode( pNtk, pNode, i )
    {
        //printf("rewrite: %d\n", pNode->Id);
        Extra_ProgressBarUpdate( pProgress, i, NULL );
        if ( i >= nNodes )
            break;
        if ( Abc_NodeIsPersistant(pNode) )
        {
            Vec_IntPush( (*pGain_rw), -99);
            fprintf(fpt, "%d, %d\n", pNode->Id, -99);
            continue;
        }
        if ( Abc_ObjFanoutNum(pNode) > 1000 )
        {
            fprintf(fpt, "%d, %d\n", pNode->Id, -99);
            Vec_IntPush( (*pGain_rw), -99);
            continue;
         }
        nGain = Rwr_NodeRewrite( pManRwr, pManCut, pNode, fUpdateLevel, fUseZeros, fPlaceEnable );
        //printf("nGain3: %d id: %d\n", nGain, i);
        fprintf(fpt, "%d, %d\n", pNode->Id, nGain);
        Vec_IntPush( (*pGain_rw), nGain);
        //printf("size of vector: %d\n", (**pGain_rw).nSize);
        //printf("write nGain in vector.\n");
 
        if ( !(nGain > 0 || (nGain == 0 && fUseZeros)) ){
            fail++;
            continue;
        }
        success++;
        pGraph = (Dec_Graph_t *)Rwr_ManReadDecs(pManRwr);
        fCompl = Rwr_ManReadCompl(pManRwr);
 
        if ( fPlaceEnable )
            Abc_AigUpdateReset( (Abc_Aig_t *)pNtk->pManFunc );
        if ( fCompl ) Dec_GraphComplement( pGraph );
clk = Abc_Clock();
        //Dec_GraphUpdateNetwork( pNode, pGraph, fUpdateLevel, nGain );
 
        if ( fCompl ) Dec_GraphComplement( pGraph );
    }
    fclose(fpt);
    printf("size of vector: %d\n", (**pGain_rw).nSize);
    //printf("nGain in vector: %d\n", (**pGain_rw).pArray[61]);
    Extra_ProgressBarStop( pProgress );
Rwr_ManAddTimeTotal( pManRwr, Abc_Clock() - clkStart );
    pManRwr->nNodesEnd = Abc_NtkNodeNum(pNtk);
    if ( fVerbose )
        Rwr_ManPrintStats( pManRwr );
    if ( fVeryVerbose )
        Rwr_ScoresReport( pManRwr );
    Rwr_ManStop( pManRwr );
    Cut_ManStop( pManCut );
    pNtk->pManCut = NULL;
 
    {
    Abc_NtkReassignIds( pNtk );
    }
    if ( fUpdateLevel )
        Abc_NtkStopReverseLevels( pNtk );
    else
        Abc_NtkLevel( pNtk );
    if ( !Abc_NtkCheck( pNtk ) )
    {
        printf( "Abc_NtkRewrite3: The network check has failed.\n" );
        return 0;
    }
        printf( "Abc_NtkRewrite3: success : %d; fail : %d\n", success, fail );
    return 1;
}

Here is the call graph for this function:

Abc_PlaceBegin()

void Abc_PlaceBegin ( Abc_Ntk_t * pNtk )

extern

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

Synopsis [This procedure is called before the writing start.]

Description []

SideEffects []

SeeAlso []

Definition at line 178 of file abcPlace.c.

{
    Abc_Obj_t * pObj;
    int i;
 
    // allocate and clean internal storage
    nAllocSize = 5 * Abc_NtkObjNumMax(pNtk);
    cells = REALLOC(ConcreteCell, cells, nAllocSize);
    nets  = REALLOC(ConcreteNet, nets, nAllocSize);
    memset( cells, 0, sizeof(ConcreteCell) * nAllocSize );
    memset( nets, 0, sizeof(ConcreteNet) * nAllocSize );
 
    // create AbstractCells
    //   1: pad
    //   2: and
    if (!abstractCells)
        abstractCells = ALLOC(AbstractCell,2);
 
    abstractCells[0].m_height = 1.0;
    abstractCells[0].m_width = 1.0;
    abstractCells[0].m_label = "pio";
    abstractCells[0].m_pad = 1;
 
    abstractCells[1].m_height = 1.0;
    abstractCells[1].m_width = 1.0;
    abstractCells[1].m_label = "and";
    abstractCells[1].m_pad = 0;
 
    // input pads
    Abc_NtkForEachCi( pNtk, pObj, i )
        Abc_PlaceCreateCell( pObj, 0 );
 
    // ouput pads
    Abc_NtkForEachCo( pNtk, pObj, i )
        Abc_PlaceCreateCell( pObj, 0 );
 
    // AND nodes
    Abc_AigForEachAnd( pNtk, pObj, i )
        Abc_PlaceCreateCell( pObj, 1 );
 
    // all nets
    Abc_NtkForEachObj( pNtk, pObj, i )
    {
        if ( !Abc_ObjIsCi(pObj) && !Abc_ObjIsNode(pObj) )
            continue;
        Abc_PlaceUpdateNet( pObj );
    }
 
    globalPreplace((float)0.8);
    globalPlace();
}

Here is the call graph for this function:

Abc_PlaceEnd()

void Abc_PlaceEnd ( Abc_Ntk_t * pNtk )

extern

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

Synopsis [This procedure is called after the writing completes.]

Description []

SideEffects []

SeeAlso []

Definition at line 241 of file abcPlace.c.

{
    int i;
 
 
    // clean up
    for ( i = 0; i < nAllocSize; i++ )
        FREE( nets[i].m_terms );
    FREE( abstractCells );
    FREE( cells );
    FREE( nets );
}

Abc_PlaceUpdate()

void Abc_PlaceUpdate ( Vec_Ptr_t * vAddedCells, Vec_Ptr_t * vUpdatedNets )

extern

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

Synopsis [Updates placement after one step of rewriting.]

Description []

SideEffects []

SeeAlso []

Definition at line 126 of file abcPlace.c.

{
    Abc_Obj_t * pObj, * pFanin;
    int i, k;
    Vec_Ptr_t * vCells, * vNets;
 
    // start the arrays of new cells and nets
    vCells = Vec_PtrAlloc( 16 );
    vNets = Vec_PtrAlloc( 32 );
 
    // go through the new nodes
    Vec_PtrForEachEntry( Abc_Obj_t *, vAddedCells, pObj, i )
    {
        assert( !Abc_ObjIsComplement(pObj) );
        Abc_PlaceCreateCell( pObj, 1 );
        Abc_PlaceUpdateNet( pObj );
 
        // add the new cell and its fanin nets to temporary storage
        Vec_PtrPush( vCells, &(cells[pObj->Id]) );
        Abc_ObjForEachFanin( pObj, pFanin, k )
            Vec_PtrPushUnique( vNets, &(nets[pFanin->Id]) );
    }
 
    // go through the modified nets
    Vec_PtrForEachEntry( Abc_Obj_t *, vUpdatedNets, pObj, i )
    {
        assert( !Abc_ObjIsComplement(pObj) );
        if ( Abc_ObjType(pObj) == ABC_OBJ_NONE ) // dead node
            continue;
        Abc_PlaceUpdateNet( pObj );
    }
 
    // update the placement
//    fastPlace( Vec_PtrSize(vCells), (ConcreteCell **)Vec_PtrArray(vCells), 
//               Vec_PtrSize(vNets), (ConcreteNet **)Vec_PtrArray(vNets) );
 
    // clean up
    Vec_PtrFree( vCells );
    Vec_PtrFree( vNets );
}

Dec_GraphUpdateNetwork()

int Dec_GraphUpdateNetwork ( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, int fUpdateLevel, int nGain )

extern

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

Synopsis [Replaces MFFC of the node by the new factored form.]

Description []

SideEffects []

SeeAlso []

Definition at line 240 of file decAbc.c.

{
    extern Abc_Obj_t *    Dec_GraphToNetwork( Abc_Ntk_t * pNtk, Dec_Graph_t * pGraph );
    Abc_Obj_t * pRootNew;
    Abc_Ntk_t * pNtk = pRoot->pNtk;
    int nNodesNew, nNodesOld, RetValue;
    nNodesOld = Abc_NtkNodeNum(pNtk);
    // create the new structure of nodes
    pRootNew = Dec_GraphToNetwork( pNtk, pGraph );
    // remove the old nodes
    RetValue = Abc_AigReplace( (Abc_Aig_t *)pNtk->pManFunc, pRoot, pRootNew, fUpdateLevel );
    // compare the gains
    nNodesNew = Abc_NtkNodeNum(pNtk);
    //assert( nGain <= nNodesOld - nNodesNew );
    return RetValue;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

s_ResubTime

abctime s_ResubTime

extern