fretMain.c File Reference

#include "fretime.h"

Include dependency graph for fretMain.c:

Go to the source code of this file.

Functions
void	Abc_NtkMarkCone_rec (Abc_Obj_t *pObj, int fForward)
void	print_node3 (Abc_Obj_t *pObj)
Abc_Ntk_t *	Abc_FlowRetime_MinReg (Abc_Ntk_t *pNtk, int fVerbose, int fComputeInitState, int fGuaranteeInitState, int fBlockConst, int fForwardOnly, int fBackwardOnly, int nMaxIters, int maxDelay, int fFastButConservative)
	FUNCTION DEFINITIONS ///.
int	Abc_FlowRetime_PushFlows (Abc_Ntk_t *pNtk, int fVerbose)
void	Abc_FlowRetime_FixLatchBoxes (Abc_Ntk_t *pNtk, Vec_Ptr_t *vBoxIns)
void	Abc_FlowRetime_CopyInitState (Abc_Obj_t *pSrc, Abc_Obj_t *pDest)
void	print_node (Abc_Obj_t *pObj)
void	print_node2 (Abc_Obj_t *pObj)
void	Abc_ObjBetterTransferFanout (Abc_Obj_t *pFrom, Abc_Obj_t *pTo, int complement)
int	Abc_FlowRetime_IsAcrossCut (Abc_Obj_t *pObj, Abc_Obj_t *pNext)
void	Abc_FlowRetime_ClearFlows (int fClearAll)
Abc_Ntk_t *	Abc_FlowRetime_NtkSilentRestrash (Abc_Ntk_t *pNtk, int fCleanup)
void	Abc_FlowRetime_UpdateLags ()
int	Abc_FlowRetime_GetLag (Abc_Obj_t *pObj)
void	Abc_FlowRetime_SetLag (Abc_Obj_t *pObj, int lag)
void	Abc_ObjPrintNeighborhood (Abc_Obj_t *pObj, int depth)

Variables
MinRegMan_t *	pManMR
int	fPathError = 0

Function Documentation

Abc_FlowRetime_ClearFlows()

void Abc_FlowRetime_ClearFlows

(

int

fClearAll

)

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

Synopsis [Resets flow problem]

Description [If fClearAll is true, all marks will be cleared; this is typically appropriate after the circuit structure has been modified.]

SideEffects []

SeeAlso []

Definition at line 1087 of file fretMain.c.

                                                {
  int i;
 
  if (fClearAll)
    memset(pManMR->pDataArray, 0, sizeof(Flow_Data_t)*pManMR->nNodes);
  else {
    // clear only data related to flow problem
    for(i=0; i<pManMR->nNodes; i++) {
      pManMR->pDataArray[i].mark &= ~(VISITED | FLOW );
      pManMR->pDataArray[i].e_dist = 0;
      pManMR->pDataArray[i].r_dist = 0;
      pManMR->pDataArray[i].pred = NULL;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_FlowRetime_CopyInitState()

void Abc_FlowRetime_CopyInitState	(	Abc_Obj_t *	pSrc,
		Abc_Obj_t *	pDest )

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

Synopsis [Copies initial state from latches to BO nodes.]

Description [Initial states are marked on BO nodes with INIT_0 and INIT_1 flags in their Flow_Data structures.]

SideEffects []

SeeAlso []

Definition at line 777 of file fretMain.c.

                                                                    {
  Abc_Obj_t *pObj;
 
  if (!pManMR->fComputeInitState) return;
 
  assert(Abc_ObjIsLatch(pSrc));
  assert(Abc_ObjFanin0(pDest) == pSrc);
  assert(!Abc_ObjFaninC0(pDest));
 
  FUNSET(pDest, INIT_CARE);
  if (Abc_LatchIsInit0(pSrc)) {
    FSET(pDest, INIT_0);
  } else if (Abc_LatchIsInit1(pSrc)) {
    FSET(pDest, INIT_1);  
  }
  
  if (!pManMR->fIsForward) {
    pObj = (Abc_Obj_t*)Abc_ObjData(pSrc);
    assert(Abc_ObjIsPi(pObj));
    FDATA(pDest)->pInitObj = pObj;
  }
}

Abc_FlowRetime_FixLatchBoxes()

void Abc_FlowRetime_FixLatchBoxes	(	Abc_Ntk_t *	pNtk,
		Vec_Ptr_t *	vBoxIns )

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

Synopsis [Restores latch boxes.]

Description [Latchless BI/BO nodes are removed. Latch boxes are restored around remaining latches.]

SideEffects [Deletes nodes as appropriate.]

SeeAlso []

Definition at line 545 of file fretMain.c.

                                                                    {
  int i;
  Abc_Obj_t *pObj, *pBo = NULL, *pBi = NULL;
  Vec_Ptr_t *vFreeBi = Vec_PtrAlloc( 100 );
  Vec_Ptr_t *vFreeBo = Vec_PtrAlloc( 100 );
 
  // 1. remove empty bi/bo pairs
  while(Vec_PtrSize( vBoxIns )) {
    pBi = (Abc_Obj_t *)Vec_PtrPop( vBoxIns );
    assert(Abc_ObjIsBi(pBi));
    assert(Abc_ObjFanoutNum(pBi) == 1);
    // APH: broken by bias nodes assert(Abc_ObjFaninNum(pBi) == 1);
    pBo = Abc_ObjFanout0(pBi);
    assert(!Abc_ObjFaninC0(pBo));
 
    if (Abc_ObjIsBo(pBo)) {
      // an empty bi/bo pair
 
      Abc_ObjRemoveFanins( pBo );
      // transfer complement from BI, if present 
      assert(!Abc_ObjIsComplement(Abc_ObjFanin0(pBi)));
      Abc_ObjBetterTransferFanout( pBo, Abc_ObjFanin0(pBi), Abc_ObjFaninC0(pBi) );
 
      Abc_ObjRemoveFanins( pBi );
      pBi->fCompl0 = 0;
      Vec_PtrPush( vFreeBi, pBi );
      Vec_PtrPush( vFreeBo, pBo );
 
      // free names
      if (Nm_ManFindNameById(pNtk->pManName, Abc_ObjId(pBi)))
        Nm_ManDeleteIdName( pNtk->pManName, Abc_ObjId(pBi));
      if (Nm_ManFindNameById(pNtk->pManName, Abc_ObjId(pBo)))
        Nm_ManDeleteIdName( pNtk->pManName, Abc_ObjId(pBo));
 
      // check for complete detachment
      assert(Abc_ObjFaninNum(pBi) == 0);
      assert(Abc_ObjFanoutNum(pBi) == 0);
      assert(Abc_ObjFaninNum(pBo) == 0);
      assert(Abc_ObjFanoutNum(pBo) == 0);
    } else if (Abc_ObjIsLatch(pBo)) {
    } else {
      Abc_ObjPrint(stdout, pBi);
      Abc_ObjPrint(stdout, pBo);
      assert(0);
    }
  }
 
  // 2. add bi/bos as necessary for latches
  Abc_NtkForEachLatch( pNtk, pObj, i ) {
    assert(Abc_ObjFaninNum(pObj) == 1);
    if (Abc_ObjFanoutNum(pObj))
      pBo = Abc_ObjFanout0(pObj);
    else pBo = NULL;
    pBi = Abc_ObjFanin0(pObj);
    
    // add BO
    if (!pBo || !Abc_ObjIsBo(pBo)) {
      pBo = (Abc_Obj_t *)Vec_PtrPop( vFreeBo );
      if (Abc_ObjFanoutNum(pObj))  Abc_ObjTransferFanout( pObj, pBo );
      Abc_ObjAddFanin( pBo, pObj );
    }
    // add BI
    if (!Abc_ObjIsBi(pBi)) {
      pBi = (Abc_Obj_t *)Vec_PtrPop( vFreeBi );
      assert(Abc_ObjFaninNum(pBi) == 0);
      Abc_ObjAddFanin( pBi, Abc_ObjFanin0(pObj) );
      pBi->fCompl0 = pObj->fCompl0;
      Abc_ObjRemoveFanins( pObj );
      Abc_ObjAddFanin( pObj, pBi );
    }
  }
 
  // delete remaining BIs and BOs
  while(Vec_PtrSize( vFreeBi )) {
    pObj = (Abc_Obj_t *)Vec_PtrPop( vFreeBi );
    Abc_NtkDeleteObj( pObj );
  }
  while(Vec_PtrSize( vFreeBo )) {
    pObj = (Abc_Obj_t *)Vec_PtrPop( vFreeBo );
    Abc_NtkDeleteObj( pObj );
  }
 
#if defined(DEBUG_CHECK)
  Abc_NtkForEachObj( pNtk, pObj, i ) {
    if (Abc_ObjIsBo(pObj)) {
      assert(Abc_ObjFaninNum(pObj) == 1);
      assert(Abc_ObjIsLatch(Abc_ObjFanin0(pObj))); 
    }
    if (Abc_ObjIsBi(pObj)) {
      assert(Abc_ObjFaninNum(pObj) == 1);
      assert(Abc_ObjFanoutNum(pObj) == 1);
      assert(Abc_ObjIsLatch(Abc_ObjFanout0(pObj))); 
    }
    if (Abc_ObjIsLatch(pObj)) {
      assert(Abc_ObjFanoutNum(pObj) == 1);
      assert(Abc_ObjFaninNum(pObj) == 1);
    }
  }
#endif
 
  Vec_PtrFree( vFreeBi );
  Vec_PtrFree( vFreeBo );
}

Here is the call graph for this function:

Abc_FlowRetime_GetLag()

int Abc_FlowRetime_GetLag

(

Abc_Obj_t *

pObj

)

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

Synopsis [Gets lag value of a node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1323 of file fretMain.c.

                                         {
  assert( !Abc_ObjIsLatch(pObj) );
  assert( (int)Abc_ObjId(pObj) < Vec_IntSize(pManMR->vLags) );
 
  return Vec_IntEntry(pManMR->vLags, Abc_ObjId(pObj));
}

Abc_FlowRetime_IsAcrossCut()

int Abc_FlowRetime_IsAcrossCut	(	Abc_Obj_t *	pObj,
		Abc_Obj_t *	pNext )

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

Synopsis [Returns true is a connection spans the min-cut.]

Description [pNext is a direct fanout of pObj.]

SideEffects []

SeeAlso []

Definition at line 1054 of file fretMain.c.

                                                                {
 
  if (FTEST(pObj, VISITED_R) && !FTEST(pObj, VISITED_E)) {
    if (pManMR->fIsForward) {
      if (!FTEST(pNext, VISITED_R) || 
          (FTEST(pNext, BLOCK_OR_CONS) & pManMR->constraintMask)|| 
          FTEST(pNext, CROSS_BOUNDARY) || 
          Abc_ObjIsLatch(pNext))
        return 1;
    } else {
      if (FTEST(pNext, VISITED_E) ||
          FTEST(pNext, CROSS_BOUNDARY))
        return 1;
    }
  }
  
  return 0;
}

Abc_FlowRetime_MinReg()

Abc_Ntk_t * Abc_FlowRetime_MinReg	(	Abc_Ntk_t *	pNtk,
		int	fVerbose,
		int	fComputeInitState,
		int	fGuaranteeInitState,
		int	fBlockConst,
		int	fForwardOnly,
		int	fBackwardOnly,
		int	nMaxIters,
		int	maxDelay,
		int	fFastButConservative )

FUNCTION DEFINITIONS ///.

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

Synopsis [Performs minimum-register retiming.]

Description []

SideEffects []

SeeAlso []

Definition at line 72 of file fretMain.c.

                                                                {
 
  int i;
  Abc_Obj_t   *pObj, *pNext;
  InitConstraint_t *pData;
 
  // create manager
  pManMR = ABC_ALLOC( MinRegMan_t, 1 );
 
  pManMR->pNtk = pNtk;
  pManMR->fVerbose = fVerbose;
  pManMR->fComputeInitState = fComputeInitState;
  pManMR->fGuaranteeInitState = fGuaranteeInitState;
  pManMR->fBlockConst = fBlockConst;
  pManMR->fForwardOnly = fForwardOnly;
  pManMR->fBackwardOnly = fBackwardOnly;
  pManMR->nMaxIters = nMaxIters;
  pManMR->maxDelay = maxDelay;
  pManMR->fComputeInitState = fComputeInitState;
  pManMR->fConservTimingOnly = fFastButConservative;
  pManMR->vNodes = Vec_PtrAlloc(100);
  pManMR->vInitConstraints = Vec_PtrAlloc(2);
  pManMR->pInitNtk = NULL;
  pManMR->pInitToOrig = NULL;
  pManMR->sizeInitToOrig = 0;
 
  vprintf("Flow-based minimum-register retiming...\n");  
 
  if (!Abc_NtkHasOnlyLatchBoxes(pNtk)) {
    printf("\tERROR: Can not retime with black/white boxes\n");
    return pNtk;
  }
 
  if (maxDelay) {
    vprintf("\tmax delay constraint = %d\n", maxDelay);
    if (maxDelay < (i = Abc_NtkLevel(pNtk))) {
      printf("ERROR: max delay constraint (%d) must be > current max delay (%d)\n", maxDelay, i);
      return pNtk;
    }
  }
 
  // print info about type of network
  vprintf("\tnetlist type = ");
  if (Abc_NtkIsNetlist( pNtk )) { vprintf("netlist/"); }
  else if (Abc_NtkIsLogic( pNtk )) { vprintf("logic/"); }
  else if (Abc_NtkIsStrash( pNtk )) { vprintf("strash/"); }
  else { vprintf("***unknown***/"); }
  if (Abc_NtkHasSop( pNtk )) { vprintf("sop\n"); }
  else if (Abc_NtkHasBdd( pNtk )) { vprintf("bdd\n"); }
  else if (Abc_NtkHasAig( pNtk )) { vprintf("aig\n"); }
  else if (Abc_NtkHasMapping( pNtk )) { vprintf("mapped\n"); }
  else { vprintf("***unknown***\n"); }
 
  vprintf("\tinitial reg count = %d\n", Abc_NtkLatchNum(pNtk));
  vprintf("\tinitial levels = %d\n", Abc_NtkLevel(pNtk));
 
  // remove bubbles from latch boxes
  if (pManMR->fVerbose) Abc_FlowRetime_PrintInitStateInfo(pNtk);
  vprintf("\tpushing bubbles out of latch boxes\n");
  Abc_NtkForEachLatch( pNtk, pObj, i )
    Abc_FlowRetime_RemoveLatchBubbles(pObj);
  if (pManMR->fVerbose) Abc_FlowRetime_PrintInitStateInfo(pNtk);
 
  // check for box inputs/outputs
  Abc_NtkForEachLatch( pNtk, pObj, i ) {
    assert(Abc_ObjFaninNum(pObj) == 1);
    assert(Abc_ObjFanoutNum(pObj) == 1);
    assert(!Abc_ObjFaninC0(pObj));
 
    pNext = Abc_ObjFanin0(pObj);
    assert(Abc_ObjIsBi(pNext));
    assert(Abc_ObjFaninNum(pNext) <= 1);
    if(Abc_ObjFaninNum(pNext) == 0) // every Bi should have a fanin
      Abc_FlowRetime_AddDummyFanin( pNext );
 
    pNext = Abc_ObjFanout0(pObj);
    assert(Abc_ObjIsBo(pNext));
    assert(Abc_ObjFaninNum(pNext) == 1);
    assert(!Abc_ObjFaninC0(pNext));
  }
 
  pManMR->nLatches = Abc_NtkLatchNum( pNtk );
  pManMR->nNodes = Abc_NtkObjNumMax( pNtk )+1;
   
  // build histogram
  pManMR->vSinkDistHist = Vec_IntStart( pManMR->nNodes*2+10 );
 
  // initialize timing
  if (maxDelay)
    Abc_FlowRetime_InitTiming( pNtk );
 
  // create lag and Flow_Data structure
  pManMR->vLags = Vec_IntStart(pManMR->nNodes);
  memset(pManMR->vLags->pArray, 0, sizeof(int)*pManMR->nNodes);
 
  pManMR->pDataArray = ABC_ALLOC( Flow_Data_t, pManMR->nNodes );
  Abc_FlowRetime_ClearFlows( 1 );
 
  // main loop!
  pNtk = Abc_FlowRetime_MainLoop();
 
  // cleanup node fields
  Abc_NtkForEachObj( pNtk, pObj, i ) {
    // if not computing init state, set all latches to DC
    if (!fComputeInitState && Abc_ObjIsLatch(pObj))
      Abc_LatchSetInitDc(pObj);
  }
 
  // deallocate space
  ABC_FREE( pManMR->pDataArray );
  if (pManMR->pInitToOrig) ABC_FREE( pManMR->pInitToOrig );
  if (pManMR->vNodes) Vec_PtrFree(pManMR->vNodes);
  if (pManMR->vLags) Vec_IntFree(pManMR->vLags);
  if (pManMR->vSinkDistHist) Vec_IntFree(pManMR->vSinkDistHist);
  if (pManMR->maxDelay) Abc_FlowRetime_FreeTiming( pNtk );
  while( Vec_PtrSize( pManMR->vInitConstraints )) {
    pData = (InitConstraint_t*)Vec_PtrPop( pManMR->vInitConstraints );
    //assert( pData->pBiasNode );
    //Abc_NtkDeleteObj( pData->pBiasNode );
    ABC_FREE( pData->vNodes.pArray );
    ABC_FREE( pData );
  }
  ABC_FREE( pManMR->vInitConstraints );
 
  // restrash if necessary
  if (Abc_NtkIsStrash(pNtk)) {
    Abc_NtkReassignIds( pNtk );
    pNtk = Abc_FlowRetime_NtkSilentRestrash( pNtk, 1 );
  }
  
  vprintf("\tfinal reg count = %d\n", Abc_NtkLatchNum(pNtk));
  vprintf("\tfinal levels = %d\n", Abc_NtkLevel(pNtk));
 
#if defined(DEBUG_CHECK)
  Abc_NtkDoCheck( pNtk );
#endif
 
  // free manager
  ABC_FREE( pManMR );
 
  return pNtk;
}

Here is the call graph for this function:

Abc_FlowRetime_NtkSilentRestrash()

Abc_Ntk_t * Abc_FlowRetime_NtkSilentRestrash	(	Abc_Ntk_t *	pNtk,
		int	fCleanup )

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

Synopsis [Silent restrash.]

Description [Same functionality as Abc_NtkRestrash but w/o warnings.]

SideEffects []

SeeAlso []

Definition at line 1184 of file fretMain.c.

{
    Abc_Ntk_t * pNtkAig;
    Abc_Obj_t * pObj;
    int i, nNodes;//, RetValue;
    assert( Abc_NtkIsStrash(pNtk) );
    // start the new network (constants and CIs of the old network will point to the their counterparts in the new network)
    pNtkAig = Abc_NtkStartFrom( pNtk, ABC_NTK_STRASH, ABC_FUNC_AIG );
    // restrash the nodes (assuming a topological order of the old network)
    Abc_NtkForEachNode( pNtk, pObj, i )
        pObj->pCopy = Abc_AigAnd( (Abc_Aig_t *)pNtkAig->pManFunc, Abc_ObjChild0Copy(pObj), Abc_ObjChild1Copy(pObj) );
    // finalize the network
    Abc_NtkFinalize( pNtk, pNtkAig );
    // perform cleanup if requested
    if ( fCleanup )
      nNodes = Abc_AigCleanup((Abc_Aig_t *)pNtkAig->pManFunc);
    // duplicate EXDC 
    if ( pNtk->pExdc )
      pNtkAig->pExdc = Abc_NtkDup( pNtk->pExdc );
    // make sure everything is okay
    if ( !Abc_NtkCheck( pNtkAig ) )
      {
        printf( "Abc_NtkStrash: The network check has failed.\n" );
        Abc_NtkDelete( pNtkAig );
        return NULL;
      }
    return pNtkAig;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_FlowRetime_PushFlows()

int Abc_FlowRetime_PushFlows	(	Abc_Ntk_t *	pNtk,
		int	fVerbose )

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

Synopsis [Computes maximum flow.]

Description []

SideEffects [Leaves VISITED flags on source-reachable nodes.]

SeeAlso []

Definition at line 479 of file fretMain.c.

                                                           {
  int i, j, flow = 0, last, srcDist = 0;
  Abc_Obj_t   *pObj, *pObj2;
//  int clk = clock();
 
  pManMR->constraintMask |= BLOCK;
 
  pManMR->fSinkDistTerminate = 0;
  dfsfast_preorder( pNtk );
 
  // (i) fast max-flow computation
  while(!pManMR->fSinkDistTerminate && srcDist < MAX_DIST) {
    srcDist = MAX_DIST;
    Abc_NtkForEachLatch( pNtk, pObj, i )
      if (FDATA(pObj)->e_dist)    
        srcDist = MIN(srcDist, (int)FDATA(pObj)->e_dist);
    
    Abc_NtkForEachLatch( pNtk, pObj, i ) {
      if (srcDist == (int)FDATA(pObj)->e_dist &&
          dfsfast_e( pObj, NULL )) {
#ifdef DEBUG_PRINT_FLOWS
        printf("\n\n");
#endif
        flow++;
      }
    }
  }
 
  if (fVerbose) vprintf("\t\tmax-flow1 = %d \t", flow);
 
  // (ii) complete max-flow computation
  // also, marks source-reachable nodes
  do {
    last = flow;
    Abc_NtkForEachLatch( pNtk, pObj, i ) {
      if (dfsplain_e( pObj, NULL )) {
#ifdef DEBUG_PRINT_FLOWS
        printf("\n\n");
#endif
        flow++;
        Abc_NtkForEachObj( pNtk, pObj2, j )
          FUNSET( pObj2, VISITED );
      }
    }
  } while (flow > last);
  
  if (fVerbose) vprintf("max-flow2 = %d\n", flow);
 
//  PRT( "time", clock() - clk );
  return flow;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_FlowRetime_SetLag()

void Abc_FlowRetime_SetLag	(	Abc_Obj_t *	pObj,
		int	lag )

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

Synopsis [Sets lag value of a node.]

Description []

SideEffects []

SeeAlso []

Definition at line 1342 of file fretMain.c.

                                                  {
  assert( Abc_ObjIsNode(pObj) );
  assert( (int)Abc_ObjId(pObj) < Vec_IntSize(pManMR->vLags) );
 
  Vec_IntWriteEntry(pManMR->vLags, Abc_ObjId(pObj), lag);
}

Abc_FlowRetime_UpdateLags()

void Abc_FlowRetime_UpdateLags

(

)

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

Synopsis [Updates lag values.]

Description []

SideEffects []

SeeAlso []

Definition at line 1294 of file fretMain.c.

                             {
  Abc_Obj_t *pObj, *pNext;
  int i, j;
 
  Abc_NtkIncrementTravId( pManMR->pNtk );
 
  Abc_NtkForEachLatch( pManMR->pNtk, pObj, i )
    if (pManMR->fIsForward) {
      Abc_ObjForEachFanin( pObj, pNext, j )          
        Abc_FlowRetime_UpdateLags_forw_rec( pNext );
    } else {
      Abc_ObjForEachFanout( pObj, pNext, j )          
        Abc_FlowRetime_UpdateLags_back_rec( pNext );
    }
}

Abc_NtkMarkCone_rec()

void Abc_NtkMarkCone_rec ( Abc_Obj_t * pObj, int fForward )

extern

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

Synopsis [Marks the cone with MarkA.]

Description []

SideEffects []

SeeAlso []

Definition at line 147 of file retArea.c.

{
    Abc_Obj_t * pNext;
    int i;
    if ( pObj->fMarkA )
        return;
    pObj->fMarkA = 1;
    if ( fForward )
    {
        Abc_ObjForEachFanout( pObj, pNext, i )
            Abc_NtkMarkCone_rec( pNext, fForward );
    }
    else
    {
        Abc_ObjForEachFanin( pObj, pNext, i )
            Abc_NtkMarkCone_rec( pNext, fForward );
    }
}

Here is the caller graph for this function:

Abc_ObjBetterTransferFanout()

void Abc_ObjBetterTransferFanout	(	Abc_Obj_t *	pFrom,
		Abc_Obj_t *	pTo,
		int	complement )

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

Synopsis [Transfers fanout.]

Description [Does not produce an error if there is no fanout. Complements as necessary.]

SideEffects []

SeeAlso []

Definition at line 1032 of file fretMain.c.

                                                                                  {
  Abc_Obj_t *pNext;
  
  while(Abc_ObjFanoutNum(pFrom) > 0) {
    pNext = Abc_ObjFanout0(pFrom);
    Abc_ObjPatchFanin( pNext, pFrom, Abc_ObjNotCond(pTo, complement) );
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_ObjPrintNeighborhood()

void Abc_ObjPrintNeighborhood	(	Abc_Obj_t *	pObj,
		int	depth )

Definition at line 1369 of file fretMain.c.

                                                            {
  Vec_Ptr_t *vNodes = Vec_PtrAlloc(100); 
  Abc_Obj_t *pObj2;
 
  Abc_ObjPrintNeighborhood_rec( pObj, vNodes, depth );
 
  while(Vec_PtrSize(vNodes)) {
    pObj2 = (Abc_Obj_t*)Vec_PtrPop(vNodes);
    pObj2->fMarkC = 0;
  }
 
  Vec_PtrFree(vNodes);
}

Here is the caller graph for this function:

print_node()

void print_node

(

Abc_Obj_t *

pObj

)

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

Synopsis [Prints information about a node.]

Description [Debuging.]

SideEffects []

SeeAlso []

Definition at line 945 of file fretMain.c.

                            {
  int i;
  Abc_Obj_t * pNext;
  char m[6];
 
  m[0] = 0;
  if (pObj->fMarkA)
    strcat(m, "A");
  if (pObj->fMarkB)
    strcat(m, "B");
  if (pObj->fMarkC)
    strcat(m, "C");
 
  printf("node %d type=%d lev=%d tedge=%d (%x%s) fanouts {", Abc_ObjId(pObj), Abc_ObjType(pObj),
         pObj->Level, Vec_PtrSize(FTIMEEDGES(pObj)), FDATA(pObj)->mark, m);
  Abc_ObjForEachFanout( pObj, pNext, i )
    printf("%d[%d](%d),", Abc_ObjId(pNext), Abc_ObjType(pNext), FDATA(pNext)->mark);
  printf("} fanins {");
  Abc_ObjForEachFanin( pObj, pNext, i )
    printf("%d[%d](%d),", Abc_ObjId(pNext), Abc_ObjType(pNext), FDATA(pNext)->mark);
  printf("}\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_node2()

void print_node2

(

Abc_Obj_t *

pObj

)

Definition at line 969 of file fretMain.c.

                             {
  int i;
  Abc_Obj_t * pNext;
  char m[6];
 
  m[0] = 0;
  if (pObj->fMarkA)
    strcat(m, "A");
  if (pObj->fMarkB)
    strcat(m, "B");
  if (pObj->fMarkC)
    strcat(m, "C");
 
  printf("node %d type=%d %s fanouts {", Abc_ObjId(pObj), Abc_ObjType(pObj), m);
  Abc_ObjForEachFanout( pObj, pNext, i )
    printf("%d ,", Abc_ObjId(pNext));
  printf("} fanins {");
  Abc_ObjForEachFanin( pObj, pNext, i )
    printf("%d ,", Abc_ObjId(pNext));
  printf("} ");
}

Here is the call graph for this function:

print_node3()

void print_node3

(

Abc_Obj_t *

pObj

)

Definition at line 992 of file fretMain.c.

                             {
  int i;
  Abc_Obj_t * pNext;
  char m[6];
 
  m[0] = 0;
  if (pObj->fMarkA)
    strcat(m, "A");
  if (pObj->fMarkB)
    strcat(m, "B");
  if (pObj->fMarkC)
    strcat(m, "C");
 
  printf("\nnode %d type=%d mark=%d %s\n", Abc_ObjId(pObj), Abc_ObjType(pObj), FDATA(pObj)->mark, m);
  printf("fanouts\n");
  Abc_ObjForEachFanout( pObj, pNext, i ) {
    print_node(pNext);
    printf("\n");
  }
  printf("fanins\n");
  Abc_ObjForEachFanin( pObj, pNext, i ) {
    print_node(pNext);
    printf("\n");
  }
}

Here is the call graph for this function:

Variable Documentation

fPathError

int fPathError = 0

Definition at line 54 of file fretMain.c.

pManMR

MinRegMan_t* pManMR

Definition at line 52 of file fretMain.c.