abcPlace.c File Reference

#include "base/abc/abc.h"
#include "phys/place/place_base.h"

Include dependency graph for abcPlace.c:

Go to the source code of this file.

Functions
float	Abc_PlaceEvaluateCut (Abc_Obj_t *pRoot, Vec_Ptr_t *vFanins)
void	Abc_PlaceUpdate (Vec_Ptr_t *vAddedCells, Vec_Ptr_t *vUpdatedNets)
void	Abc_PlaceBegin (Abc_Ntk_t *pNtk)
void	Abc_PlaceEnd (Abc_Ntk_t *pNtk)

Variables
ABC_NAMESPACE_IMPL_START AbstractCell *	abstractCells = NULL
	DECLARATIONS ///.
ConcreteCell *	cells = NULL
ConcreteNet *	nets = NULL
int	nAllocSize = 0

Function Documentation

Abc_PlaceBegin()

void Abc_PlaceBegin

(

Abc_Ntk_t *

pNtk

)

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

)

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_PlaceEvaluateCut()

float Abc_PlaceEvaluateCut	(	Abc_Obj_t *	pRoot,
		Vec_Ptr_t *	vFanins )

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

Synopsis [Returns the placement cost of the cut.]

Description []

SideEffects []

SeeAlso []

Definition at line 103 of file abcPlace.c.

{
    Abc_Obj_t * pObj;
//    double x, y;
    int i;
    Vec_PtrForEachEntry( Abc_Obj_t *, vFanins, pObj, i )
    {
//        pObj->Id
    }
    return 0.0;
}

Abc_PlaceUpdate()

void Abc_PlaceUpdate	(	Vec_Ptr_t *	vAddedCells,
		Vec_Ptr_t *	vUpdatedNets )

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 );
}

Variable Documentation

abstractCells

ABC_NAMESPACE_IMPL_START AbstractCell* abstractCells = NULL

DECLARATIONS ///.

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

FileName [abcPlace.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Network and node package.]

Synopsis [Interface with a placer.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id

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

]

Definition at line 33 of file abcPlace.c.

cells

ConcreteCell* cells = NULL

Definition at line 34 of file abcPlace.c.

nAllocSize

int nAllocSize = 0

Definition at line 36 of file abcPlace.c.

nets

ConcreteNet* nets = NULL

Definition at line 35 of file abcPlace.c.