fretTime.c File Reference

#include "fretime.h"

Include dependency graph for fretTime.c:

Go to the source code of this file.

Functions
void	trace2 (Abc_Obj_t *pObj)
void	Abc_FlowRetime_InitTiming (Abc_Ntk_t *pNtk)
	FUNCTION DEFINITIONS ///.
void	Abc_FlowRetime_ConstrainConserv (Abc_Ntk_t *pNtk)
void	Abc_FlowRetime_ConstrainExact (Abc_Obj_t *pObj)
void	Abc_FlowRetime_ConstrainExact_forw_rec (Abc_Obj_t *pObj, Vec_Ptr_t *vNodes, int latch)
void	Abc_FlowRetime_ConstrainExact_back_rec (Abc_Obj_t *pObj, Vec_Ptr_t *vNodes, int latch)
void	Abc_FlowRetime_ConstrainExactAll (Abc_Ntk_t *pNtk)
void	Abc_FlowRetime_FreeTiming (Abc_Ntk_t *pNtk)
int	Abc_FlowRetime_RefineConstraints ()

Function Documentation

Abc_FlowRetime_ConstrainConserv()

void Abc_FlowRetime_ConstrainConserv

(

Abc_Ntk_t *

pNtk

)

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

Synopsis [Marks nodes with conservative constraints.]

Description []

SideEffects []

SeeAlso []

Definition at line 90 of file fretTime.c.

                                                         {  
  Abc_Obj_t *pObj;
  int i;
  void *pArray;
 
  // clear all exact constraints
  pManMR->nExactConstraints = 0;
  while( Vec_PtrSize( pManMR->vExactNodes )) {
    pObj = (Abc_Obj_t*)Vec_PtrPop( pManMR->vExactNodes );
    
    if ( Vec_PtrSize( FTIMEEDGES(pObj) )) {
      pArray =  Vec_PtrReleaseArray( FTIMEEDGES(pObj) );
      ABC_FREE( pArray );
    }
  }
 
#if !defined(IGNORE_TIMING)
  if (pManMR->fIsForward) {
    Abc_FlowRetime_ConstrainConserv_forw(pNtk);
  } else {
    Abc_FlowRetime_ConstrainConserv_back(pNtk);
  }
#endif
 
  Abc_NtkForEachObj( pNtk, pObj, i)
    assert( !Vec_PtrSize(FTIMEEDGES(pObj)) );
}

Abc_FlowRetime_ConstrainExact()

void Abc_FlowRetime_ConstrainExact

(

Abc_Obj_t *

pObj

)

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

Synopsis [Introduces exact timing constraints for a node.]

Description []

SideEffects []

SeeAlso []

Definition at line 407 of file fretTime.c.

                                                       {
 
  if (FTEST( pObj, CONSERVATIVE )) {
    pManMR->nConservConstraints--;
    FUNSET( pObj, CONSERVATIVE );
  }
 
#if !defined(IGNORE_TIMING)
  if (pManMR->fIsForward) {
    Abc_FlowRetime_ConstrainExact_forw(pObj);
  } else {
    Abc_FlowRetime_ConstrainExact_back(pObj);
  }
#endif
}

Here is the caller graph for this function:

Abc_FlowRetime_ConstrainExact_back_rec()

void Abc_FlowRetime_ConstrainExact_back_rec	(	Abc_Obj_t *	pObj,
		Vec_Ptr_t *	vNodes,
		int	latch )

Definition at line 497 of file fretTime.c.

                                                                                              {
  Abc_Obj_t *pNext;
  int i;
 
  // terminate?
  if (Abc_ObjIsLatch(pObj)) {
    if (latch) return;
    latch = 1;
  }
 
  // already visited?
  if (!latch) {
    if (pObj->fMarkA) return;
    pObj->fMarkA = 1;
  } else {
    if (pObj->fMarkB) return;
    pObj->fMarkB = 1;
  }
 
  // recurse
  Abc_ObjForEachFanout(pObj, pNext, i) {
    Abc_FlowRetime_ConstrainExact_back_rec( pNext, vNodes, latch );
  }
 
  // add
  pObj->Level = 0;
  Vec_PtrPush(vNodes, Abc_ObjNotCond(pObj, latch));
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_FlowRetime_ConstrainExact_forw_rec()

void Abc_FlowRetime_ConstrainExact_forw_rec	(	Abc_Obj_t *	pObj,
		Vec_Ptr_t *	vNodes,
		int	latch )

Definition at line 423 of file fretTime.c.

                                                                                              {
  Abc_Obj_t *pNext;
  int i;
 
  // terminate?
  if (Abc_ObjIsLatch(pObj)) {
    if (latch) return;
    latch = 1;
  }
 
  // already visited?
  if (!latch) {
    if (pObj->fMarkA) return;
    pObj->fMarkA = 1;
  } else {
    if (pObj->fMarkB) return;
    pObj->fMarkB = 1;
  }
 
  // recurse
  Abc_ObjForEachFanin(pObj, pNext, i) {
    Abc_FlowRetime_ConstrainExact_forw_rec( pNext, vNodes, latch );
  }
 
  // add
  pObj->Level = 0;
  Vec_PtrPush(vNodes, Abc_ObjNotCond(pObj, latch));
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_FlowRetime_ConstrainExactAll()

void Abc_FlowRetime_ConstrainExactAll

(

Abc_Ntk_t *

pNtk

)

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

Synopsis [Introduces all exact timing constraints in a network]

Description []

SideEffects []

SeeAlso []

Definition at line 584 of file fretTime.c.

                                                          {
  int i;
  Abc_Obj_t *pObj;
  void *pArray;
  
  // free existing constraints
  Abc_NtkForEachObj( pNtk, pObj, i )    
    if ( Vec_PtrSize( FTIMEEDGES(pObj) )) {
      pArray =  Vec_PtrReleaseArray( FTIMEEDGES(pObj) );
      ABC_FREE( pArray );
    }
  pManMR->nExactConstraints = 0;
  
  // generate all constraints
  Abc_NtkForEachObj(pNtk, pObj, i)
    if (!Abc_ObjIsLatch(pObj) && FTEST( pObj, CONSERVATIVE ) && !FTEST( pObj, BLOCK ))
      if (!Vec_PtrSize( FTIMEEDGES( pObj ) ))
        Abc_FlowRetime_ConstrainExact( pObj );
}

Here is the call graph for this function:

Abc_FlowRetime_FreeTiming()

void Abc_FlowRetime_FreeTiming

(

Abc_Ntk_t *

pNtk

)

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

Synopsis [Deallocates exact constraints.]

Description []

SideEffects []

SeeAlso []

Definition at line 617 of file fretTime.c.

                                                  {
  Abc_Obj_t *pObj;
  void *pArray;
 
  while( Vec_PtrSize( pManMR->vExactNodes )) {
    pObj = (Abc_Obj_t*)Vec_PtrPop( pManMR->vExactNodes );
    
    if ( Vec_PtrSize( FTIMEEDGES(pObj) )) {
      pArray =  Vec_PtrReleaseArray( FTIMEEDGES(pObj) );
      ABC_FREE( pArray );
    }
  }
 
  Vec_PtrFree(pManMR->vExactNodes);
  ABC_FREE( pManMR->vTimeEdges );
}

Here is the caller graph for this function:

Abc_FlowRetime_InitTiming()

void Abc_FlowRetime_InitTiming

(

Abc_Ntk_t *

pNtk

)

FUNCTION DEFINITIONS ///.

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

Synopsis [Initializes timing]

Description []

SideEffects []

SeeAlso []

Definition at line 67 of file fretTime.c.

                                                  {
 
  pManMR->nConservConstraints = pManMR->nExactConstraints = 0;
 
  pManMR->vExactNodes = Vec_PtrAlloc(1000);
 
  pManMR->vTimeEdges = ABC_ALLOC( Vec_Ptr_t, Abc_NtkObjNumMax(pNtk)+1 );
  assert(pManMR->vTimeEdges);
  memset(pManMR->vTimeEdges, 0, (Abc_NtkObjNumMax(pNtk)+1) * sizeof(Vec_Ptr_t) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Abc_FlowRetime_RefineConstraints()

int Abc_FlowRetime_RefineConstraints

(

)

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

Synopsis [Main timing-constrained routine.]

Description [Refines constraints that are limiting area improvement. These are identified by computing the min-cuts both with and without the conservative constraints: these two situation represent an over- and under-constrained version of the timing.]

SideEffects []

SeeAlso []

Definition at line 693 of file fretTime.c.

                                        {
  Abc_Ntk_t *pNtk = pManMR->pNtk;
  int i, flow, count = 0;
  Abc_Obj_t *pObj;
  int maxTighten = 99999;
 
  vprintf("\t\tsubiter %d : constraints = {cons, exact} = %d, %d\n", 
         pManMR->subIteration, pManMR->nConservConstraints, pManMR->nExactConstraints);
 
  // 1. overconstrained
  pManMR->constraintMask = BLOCK | CONSERVATIVE;
  vprintf("\t\trefinement: over ");
  fflush(stdout);
  flow = Abc_FlowRetime_PushFlows( pNtk, 0 );
  vprintf("= %d ", flow);
 
  // remember nodes
  if (pManMR->fIsForward) {
    Abc_NtkForEachObj( pNtk, pObj, i )
      if (!FTEST(pObj, VISITED_R))
        pObj->fMarkC = 1;
  } else {
    Abc_NtkForEachObj( pNtk, pObj, i )
      if (!FTEST(pObj, VISITED_E))
        pObj->fMarkC = 1;
  }
 
  if (pManMR->fConservTimingOnly) {
    vprintf(" done\n");
    return 0;
  }
 
  // 2. underconstrained
  pManMR->constraintMask = BLOCK;
  Abc_FlowRetime_ClearFlows( 0 );
  vprintf("under = ");
  fflush(stdout);
  flow = Abc_FlowRetime_PushFlows( pNtk, 0 );
  vprintf("%d refined nodes = ", flow);
  fflush(stdout);
 
  // find area-limiting constraints
  if (pManMR->fIsForward) {
    Abc_NtkForEachObj( pNtk, pObj, i ) {
      if (pObj->fMarkC &&
          FTEST(pObj, VISITED_R) &&
          FTEST(pObj, CONSERVATIVE) && 
          count < maxTighten) {
        count++;
        Abc_FlowRetime_ConstrainExact( pObj );
      }
      pObj->fMarkC = 0;
    }
  } else {
    Abc_NtkForEachObj( pNtk, pObj, i ) {
      if (pObj->fMarkC &&
          FTEST(pObj, VISITED_E) &&
          FTEST(pObj, CONSERVATIVE) &&
          count < maxTighten) {
        count++;
        Abc_FlowRetime_ConstrainExact( pObj );
      }
      pObj->fMarkC = 0;
    }
  }
  
  vprintf("%d\n", count);
  
  return (count > 0);
}

Here is the call graph for this function:

trace2()

void trace2

(

Abc_Obj_t *

pObj

)

Definition at line 39 of file fretTime.c.

                             {
  Abc_Obj_t *pNext;
  int i;
 
  print_node(pObj);
  Abc_ObjForEachFanin(pObj, pNext, i) 
    if (pNext->Level >= pObj->Level - 1) {
      trace2(pNext);
      break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function: