ivyOper.c File Reference

#include "ivy.h"

Include dependency graph for ivyOper.c:

Go to the source code of this file.

Functions
Ivy_Obj_t *	Ivy_Oper (Ivy_Man_t *p, Ivy_Obj_t *p0, Ivy_Obj_t *p1, Ivy_Type_t Type)
	FUNCTION DEFINITIONS ///.
Ivy_Obj_t *	Ivy_And (Ivy_Man_t *p, Ivy_Obj_t *p0, Ivy_Obj_t *p1)
Ivy_Obj_t *	Ivy_Exor (Ivy_Man_t *p, Ivy_Obj_t *p0, Ivy_Obj_t *p1)
Ivy_Obj_t *	Ivy_Or (Ivy_Man_t *p, Ivy_Obj_t *p0, Ivy_Obj_t *p1)
Ivy_Obj_t *	Ivy_Mux (Ivy_Man_t *p, Ivy_Obj_t *pC, Ivy_Obj_t *p1, Ivy_Obj_t *p0)
Ivy_Obj_t *	Ivy_Maj (Ivy_Man_t *p, Ivy_Obj_t *pA, Ivy_Obj_t *pB, Ivy_Obj_t *pC)
Ivy_Obj_t *	Ivy_Multi_rec (Ivy_Man_t *p, Ivy_Obj_t **ppObjs, int nObjs, Ivy_Type_t Type)
Ivy_Obj_t *	Ivy_Multi (Ivy_Man_t *p, Ivy_Obj_t **pArgs, int nArgs, Ivy_Type_t Type)
Ivy_Obj_t *	Ivy_Miter (Ivy_Man_t *p, Vec_Ptr_t *vPairs)
Ivy_Obj_t *	Ivy_Latch (Ivy_Man_t *p, Ivy_Obj_t *pObj, Ivy_Init_t Init)

Function Documentation

Ivy_And()

Ivy_Obj_t * Ivy_And	(	Ivy_Man_t *	p,
		Ivy_Obj_t *	p0,
		Ivy_Obj_t *	p1 )

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

Synopsis [Performs canonicization step.]

Description [The argument nodes can be complemented.]

SideEffects []

SeeAlso []

Definition at line 84 of file ivyOper.c.

{
//    Ivy_Obj_t * pFan0, * pFan1;
    // check trivial cases
    if ( p0 == p1 )
        return p0;
    if ( p0 == Ivy_Not(p1) )
        return Ivy_Not(p->pConst1);
    if ( Ivy_Regular(p0) == p->pConst1 )
        return p0 == p->pConst1 ? p1 : Ivy_Not(p->pConst1);
    if ( Ivy_Regular(p1) == p->pConst1 )
        return p1 == p->pConst1 ? p0 : Ivy_Not(p->pConst1);
    // check if it can be an EXOR gate
//    if ( Ivy_ObjIsExorType( p0, p1, &pFan0, &pFan1 ) )
//        return Ivy_CanonExor( pFan0, pFan1 );
    return Ivy_CanonAnd( p, p0, p1 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Ivy_Exor()

Ivy_Obj_t * Ivy_Exor	(	Ivy_Man_t *	p,
		Ivy_Obj_t *	p0,
		Ivy_Obj_t *	p1 )

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

Synopsis [Performs canonicization step.]

Description [The argument nodes can be complemented.]

SideEffects []

SeeAlso []

Definition at line 113 of file ivyOper.c.

{
/*
    // check trivial cases
    if ( p0 == p1 )
        return Ivy_Not(p->pConst1);
    if ( p0 == Ivy_Not(p1) )
        return p->pConst1;
    if ( Ivy_Regular(p0) == p->pConst1 )
        return Ivy_NotCond( p1, p0 == p->pConst1 );
    if ( Ivy_Regular(p1) == p->pConst1 )
        return Ivy_NotCond( p0, p1 == p->pConst1 );
    // check the table
    return Ivy_CanonExor( p, p0, p1 );
*/
    return Ivy_Or( p, Ivy_And(p, p0, Ivy_Not(p1)), Ivy_And(p, Ivy_Not(p0), p1) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Ivy_Latch()

Ivy_Obj_t * Ivy_Latch	(	Ivy_Man_t *	p,
		Ivy_Obj_t *	pObj,
		Ivy_Init_t	Init )

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

Synopsis [Performs canonicization step.]

Description []

SideEffects []

SeeAlso []

Definition at line 287 of file ivyOper.c.

{
    return Ivy_CanonLatch( p, pObj, Init );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Ivy_Maj()

Ivy_Obj_t * Ivy_Maj	(	Ivy_Man_t *	p,
		Ivy_Obj_t *	pA,
		Ivy_Obj_t *	pB,
		Ivy_Obj_t *	pC )

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

Synopsis [Implements ITE operation.]

Description []

SideEffects []

SeeAlso []

Definition at line 209 of file ivyOper.c.

{
    return Ivy_Or( p, Ivy_Or(p, Ivy_And(p, pA, pB), Ivy_And(p, pA, pC)), Ivy_And(p, pB, pC) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Ivy_Miter()

Ivy_Obj_t * Ivy_Miter	(	Ivy_Man_t *	p,
		Vec_Ptr_t *	vPairs )

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

Synopsis [Implements the miter.]

Description []

SideEffects []

SeeAlso []

Definition at line 264 of file ivyOper.c.

{
    int i;
    assert( vPairs->nSize > 0 );
    assert( vPairs->nSize % 2 == 0 );
    // go through the cubes of the node's SOP
    for ( i = 0; i < vPairs->nSize; i += 2 )
        vPairs->pArray[i/2] = Ivy_Not( Ivy_Exor( p, (Ivy_Obj_t *)vPairs->pArray[i], (Ivy_Obj_t *)vPairs->pArray[i+1] ) );
    vPairs->nSize = vPairs->nSize/2;
    return Ivy_Not( Ivy_Multi_rec( p, (Ivy_Obj_t **)vPairs->pArray, vPairs->nSize, IVY_AND ) );
}

Here is the call graph for this function:

Ivy_Multi()

Ivy_Obj_t * Ivy_Multi	(	Ivy_Man_t *	p,
		Ivy_Obj_t **	pArgs,
		int	nArgs,
		Ivy_Type_t	Type )

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

Synopsis [Old code.]

Description []

SideEffects []

SeeAlso []

Definition at line 246 of file ivyOper.c.

{
    assert( Type == IVY_AND || Type == IVY_EXOR );
    assert( nArgs > 0 );
    return Ivy_Multi_rec( p, pArgs, nArgs, Type );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Ivy_Multi_rec()

Ivy_Obj_t * Ivy_Multi_rec	(	Ivy_Man_t *	p,
		Ivy_Obj_t **	ppObjs,
		int	nObjs,
		Ivy_Type_t	Type )

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

Synopsis [Constructs the well-balanced tree of gates.]

Description [Disregards levels and possible logic sharing.]

SideEffects []

SeeAlso []

Definition at line 225 of file ivyOper.c.

{
    Ivy_Obj_t * pObj1, * pObj2;
    if ( nObjs == 1 )
        return ppObjs[0];
    pObj1 = Ivy_Multi_rec( p, ppObjs,           nObjs/2,         Type );
    pObj2 = Ivy_Multi_rec( p, ppObjs + nObjs/2, nObjs - nObjs/2, Type );
    return Ivy_Oper( p, pObj1, pObj2, Type );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Ivy_Mux()

Ivy_Obj_t * Ivy_Mux	(	Ivy_Man_t *	p,
		Ivy_Obj_t *	pC,
		Ivy_Obj_t *	p1,
		Ivy_Obj_t *	p0 )

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

Synopsis [Implements ITE operation.]

Description []

SideEffects []

SeeAlso []

Definition at line 158 of file ivyOper.c.

{
    Ivy_Obj_t * pTempA1, * pTempA2, * pTempB1, * pTempB2, * pTemp;
    int Count0, Count1;
    // consider trivial cases
    if ( p0 == Ivy_Not(p1) )
        return Ivy_Exor( p, pC, p0 );
    // other cases can be added
    // implement the first MUX (F = C * x1 + C' * x0)
    pTempA1 = Ivy_TableLookup( p, Ivy_ObjCreateGhost(p, pC,          p1, IVY_AND, IVY_INIT_NONE) );
    pTempA2 = Ivy_TableLookup( p, Ivy_ObjCreateGhost(p, Ivy_Not(pC), p0, IVY_AND, IVY_INIT_NONE) );
    if ( pTempA1 && pTempA2 )
    {
        pTemp = Ivy_TableLookup( p, Ivy_ObjCreateGhost(p, Ivy_Not(pTempA1), Ivy_Not(pTempA2), IVY_AND, IVY_INIT_NONE) );
        if ( pTemp ) return Ivy_Not(pTemp);
    }
    Count0 = (pTempA1 != NULL) + (pTempA2 != NULL);
    // implement the second MUX (F' = C * x1' + C' * x0')
    pTempB1 = Ivy_TableLookup( p, Ivy_ObjCreateGhost(p, pC,          Ivy_Not(p1), IVY_AND, IVY_INIT_NONE) );
    pTempB2 = Ivy_TableLookup( p, Ivy_ObjCreateGhost(p, Ivy_Not(pC), Ivy_Not(p0), IVY_AND, IVY_INIT_NONE) );
    if ( pTempB1 && pTempB2 )
    {
        pTemp = Ivy_TableLookup( p, Ivy_ObjCreateGhost(p, Ivy_Not(pTempB1), Ivy_Not(pTempB2), IVY_AND, IVY_INIT_NONE) );
        if ( pTemp ) return pTemp;
    }
    Count1 = (pTempB1 != NULL) + (pTempB2 != NULL);
    // compare and decide which one to implement
    if ( Count0 >= Count1 )
    {
        pTempA1 = pTempA1? pTempA1 : Ivy_And(p, pC,          p1);
        pTempA2 = pTempA2? pTempA2 : Ivy_And(p, Ivy_Not(pC), p0);
        return Ivy_Or( p, pTempA1, pTempA2 );
    }
    pTempB1 = pTempB1? pTempB1 : Ivy_And(p, pC,          Ivy_Not(p1));
    pTempB2 = pTempB2? pTempB2 : Ivy_And(p, Ivy_Not(pC), Ivy_Not(p0));
    return Ivy_Not( Ivy_Or( p, pTempB1, pTempB2 ) );
 
//    return Ivy_Or( Ivy_And(pC, p1), Ivy_And(Ivy_Not(pC), p0) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Ivy_Oper()

Ivy_Obj_t * Ivy_Oper	(	Ivy_Man_t *	p,
		Ivy_Obj_t *	p0,
		Ivy_Obj_t *	p1,
		Ivy_Type_t	Type )

FUNCTION DEFINITIONS ///.

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

Synopsis [Perform one operation.]

Description [The argument nodes can be complemented.]

SideEffects []

SeeAlso []

Definition at line 63 of file ivyOper.c.

{
    if ( Type == IVY_AND )
        return Ivy_And( p, p0, p1 );
    if ( Type == IVY_EXOR )
        return Ivy_Exor( p, p0, p1 );
    assert( 0 );
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Ivy_Or()

Ivy_Obj_t * Ivy_Or	(	Ivy_Man_t *	p,
		Ivy_Obj_t *	p0,
		Ivy_Obj_t *	p1 )

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

Synopsis [Implements Boolean OR.]

Description []

SideEffects []

SeeAlso []

Definition at line 142 of file ivyOper.c.

{
    return Ivy_Not( Ivy_And( p, Ivy_Not(p0), Ivy_Not(p1) ) );
}

Here is the call graph for this function:

Here is the caller graph for this function: