cutInt.h File Reference

#include <stdio.h>
#include "misc/extra/extra.h"
#include "misc/vec/vec.h"
#include "cut.h"
#include "cutList.h"

Include dependency graph for cutInt.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	Cut_ManStruct_t_

Macros
#define	Cut_ListForEachCut(pList, pCut)
#define	Cut_ListForEachCutStop(pList, pCut, pStop)
#define	Cut_ListForEachCutSafe(pList, pCut, pCut2)

Typedefs
typedef typedefABC_NAMESPACE_HEADER_START struct Cut_HashTableStruct_t_	Cut_HashTable_t
	INCLUDES ///.

Functions
Cut_Cut_t *	Cut_CutAlloc (Cut_Man_t *p)
	FUNCTION DECLARATIONS ///.
void	Cut_CutRecycle (Cut_Man_t *p, Cut_Cut_t *pCut)
int	Cut_CutCompare (Cut_Cut_t *pCut1, Cut_Cut_t *pCut2)
Cut_Cut_t *	Cut_CutDupList (Cut_Man_t *p, Cut_Cut_t *pList)
void	Cut_CutRecycleList (Cut_Man_t *p, Cut_Cut_t *pList)
Cut_Cut_t *	Cut_CutMergeLists (Cut_Cut_t *pList1, Cut_Cut_t *pList2)
void	Cut_CutNumberList (Cut_Cut_t *pList)
Cut_Cut_t *	Cut_CutCreateTriv (Cut_Man_t *p, int Node)
void	Cut_CutPrintMerge (Cut_Cut_t *pCut, Cut_Cut_t *pCut0, Cut_Cut_t *pCut1)
Cut_Cut_t *	Cut_CutMergeTwo (Cut_Man_t *p, Cut_Cut_t *pCut0, Cut_Cut_t *pCut1)
void	Cut_NodeDoComputeCuts (Cut_Man_t *p, Cut_List_t *pSuper, int Node, int fCompl0, int fCompl1, Cut_Cut_t *pList0, Cut_Cut_t *pList1, int fTriv, int TreeCode)
int	Cut_CutListVerify (Cut_Cut_t *pList)
Cut_HashTable_t *	Cut_TableStart (int Size)
void	Cut_TableStop (Cut_HashTable_t *pTable)
int	Cut_TableLookup (Cut_HashTable_t *pTable, Cut_Cut_t *pCut, int fStore)
void	Cut_TableClear (Cut_HashTable_t *pTable)
int	Cut_TableReadTime (Cut_HashTable_t *pTable)
void	Cut_TruthComputeOld (Cut_Cut_t *pCut, Cut_Cut_t *pCut0, Cut_Cut_t *pCut1, int fCompl0, int fCompl1)
void	Cut_TruthCompute (Cut_Man_t *p, Cut_Cut_t *pCut, Cut_Cut_t *pCut0, Cut_Cut_t *pCut1, int fCompl0, int fCompl1)

Macro Definition Documentation

Cut_ListForEachCut

#define Cut_ListForEachCut	(		pList,
			pCut )

Value:

    for ( pCut = pList;                                   \
          pCut;                                           \
          pCut = pCut->pNext )

Definition at line 104 of file cutInt.h.

#define Cut_ListForEachCut( pList, pCut )                 \
    for ( pCut = pList;                                   \
          pCut;                                           \
          pCut = pCut->pNext )

Cut_ListForEachCutSafe

#define Cut_ListForEachCutSafe	(		pList,
			pCut,
			pCut2 )

Value:

    for ( pCut = pList,                                   \
          pCut2 = pCut? pCut->pNext: NULL;                \
          pCut;                                           \
          pCut = pCut2,                                   \
          pCut2 = pCut? pCut->pNext: NULL )

Definition at line 112 of file cutInt.h.

#define Cut_ListForEachCutSafe( pList, pCut, pCut2 )      \
    for ( pCut = pList,                                   \
          pCut2 = pCut? pCut->pNext: NULL;                \
          pCut;                                           \
          pCut = pCut2,                                   \
          pCut2 = pCut? pCut->pNext: NULL )

Cut_ListForEachCutStop

#define Cut_ListForEachCutStop	(		pList,
			pCut,
			pStop )

Value:

    for ( pCut = pList;                                   \
          pCut != pStop;                                  \
          pCut = pCut->pNext )

Definition at line 108 of file cutInt.h.

#define Cut_ListForEachCutStop( pList, pCut, pStop )      \
    for ( pCut = pList;                                   \
          pCut != pStop;                                  \
          pCut = pCut->pNext )

Typedef Documentation

Cut_HashTable_t

typedef typedefABC_NAMESPACE_HEADER_START struct Cut_HashTableStruct_t_ Cut_HashTable_t

INCLUDES ///.

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

FileName [cutInt.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [K-feasible cut computation package.]

Synopsis [External declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id

cutInt.h,v 1.00 2005/06/20 00:00:00 alanmi Exp

] PARAMETERS /// BASIC TYPES ///

Definition at line 46 of file cutInt.h.

Function Documentation

Cut_CutAlloc()

Cut_Cut_t * Cut_CutAlloc ( Cut_Man_t * p )

extern

FUNCTION DECLARATIONS ///.

FUNCTION DECLARATIONS ///.

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

FileName [cutNode.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [K-feasible cut computation package.]

Synopsis [Procedures to compute cuts for a node.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id

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

] FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Allocates the cut.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file cutCut.c.

{
    Cut_Cut_t * pCut;
    // cut allocation
    pCut = (Cut_Cut_t *)Extra_MmFixedEntryFetch( p->pMmCuts );
    memset( pCut, 0, sizeof(Cut_Cut_t) );
    pCut->nVarsMax   = p->pParams->nVarsMax;
    pCut->fSimul     = p->fSimul;
    // statistics
    p->nCutsAlloc++;
    p->nCutsCur++;
    if ( p->nCutsPeak < p->nCutsAlloc - p->nCutsDealloc )
        p->nCutsPeak = p->nCutsAlloc - p->nCutsDealloc;
    return pCut;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Cut_CutCompare()

int Cut_CutCompare ( Cut_Cut_t * pCut1, Cut_Cut_t * pCut2 )

extern

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

Synopsis [Compares two cuts.]

Description []

SideEffects []

SeeAlso []

Definition at line 92 of file cutCut.c.

{
    int i;
    if ( pCut1->nLeaves < pCut2->nLeaves )
        return -1;
    if ( pCut1->nLeaves > pCut2->nLeaves )
        return 1;
    for ( i = 0; i < (int)pCut1->nLeaves; i++ )
    {
        if ( pCut1->pLeaves[i] < pCut2->pLeaves[i] )
            return -1;
        if ( pCut1->pLeaves[i] > pCut2->pLeaves[i] )
            return 1;
    }
    return 0;
}

Here is the caller graph for this function:

Cut_CutCreateTriv()

Cut_Cut_t * Cut_CutCreateTriv ( Cut_Man_t * p, int Node )

extern

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

Synopsis [Creates the trivial cut.]

Description []

SideEffects []

SeeAlso []

Definition at line 238 of file cutCut.c.

{
    Cut_Cut_t * pCut;
    if ( p->pParams->fSeq )
        Node <<= CUT_SHIFT;
    pCut = Cut_CutAlloc( p );
    pCut->nLeaves    = 1;
    pCut->pLeaves[0] = Node;
    pCut->uSign      = Cut_NodeSign( Node );
    if ( p->pParams->fTruth )
    {
/*
        if ( pCut->nVarsMax == 4 )
            Cut_CutWriteTruth( pCut, p->uTruthVars[0] );
        else
            Extra_BitCopy( pCut->nLeaves, p->uTruths[0], (uint8*)Cut_CutReadTruth(pCut) );
*/
        unsigned * pTruth = Cut_CutReadTruth(pCut);
        int i;
        for ( i = 0; i < p->nTruthWords; i++ )
            pTruth[i] = 0xAAAAAAAA;
    }
    p->nCutsTriv++;
    return pCut;
} 

Here is the call graph for this function:

Here is the caller graph for this function:

Cut_CutDupList()

Cut_Cut_t * Cut_CutDupList ( Cut_Man_t * p, Cut_Cut_t * pList )

extern

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

Synopsis [Duplicates the list.]

Description []

SideEffects []

SeeAlso []

Definition at line 120 of file cutCut.c.

{
    Cut_Cut_t * pHead = NULL, ** ppTail = &pHead;
    Cut_Cut_t * pTemp, * pCopy;
    if ( pList == NULL )
        return NULL;
    Cut_ListForEachCut( pList, pTemp )
    {
        pCopy = (Cut_Cut_t *)Extra_MmFixedEntryFetch( p->pMmCuts );
        memcpy( pCopy, pTemp, (size_t)p->EntrySize );
        *ppTail = pCopy;
        ppTail = &pCopy->pNext;
    }
    *ppTail = NULL;
    return pHead;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Cut_CutListVerify()

int Cut_CutListVerify ( Cut_Cut_t * pList )

extern

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

Synopsis [Verifies that the list contains only non-dominated cuts.]

Description []

SideEffects []

SeeAlso []

Definition at line 979 of file cutNode.c.

{ 
    Cut_Cut_t * pCut, * pDom;
    Cut_ListForEachCut( pList, pCut )
    {
        Cut_ListForEachCutStop( pList, pDom, pCut )
        {
            if ( Cut_CutCheckDominance( pDom, pCut ) )
            {
                printf( "******************* These are contained cuts:\n" );
                Cut_CutPrint( pDom, 1 );
                Cut_CutPrint( pDom, 1 );
                return 0;
            }
        }
    }
    return 1;
}

Here is the call graph for this function:

Cut_CutMergeLists()

Cut_Cut_t * Cut_CutMergeLists ( Cut_Cut_t * pList1, Cut_Cut_t * pList2 )

extern

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

Synopsis [Merges two NULL-terminated linked lists.]

Description []

SideEffects []

SeeAlso []

Definition at line 185 of file cutCut.c.

{
    Cut_Cut_t * pList = NULL, ** ppTail = &pList;
    Cut_Cut_t * pCut;
    while ( pList1 && pList2 )
    {
        if ( Cut_CutCompare(pList1, pList2) < 0 )
        {
            pCut = pList1;
            pList1 = pList1->pNext;
        }
        else
        {
            pCut = pList2;
            pList2 = pList2->pNext;
        }
        *ppTail = pCut;
        ppTail = &pCut->pNext;
    }
    *ppTail = pList1? pList1: pList2;
    return pList;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Cut_CutMergeTwo()

Cut_Cut_t * Cut_CutMergeTwo ( Cut_Man_t * p, Cut_Cut_t * pCut0, Cut_Cut_t * pCut1 )

extern

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

Synopsis [Merges two cuts.]

Description []

SideEffects []

SeeAlso []

Definition at line 170 of file cutMerge.c.

{ 
    Cut_Cut_t * pRes;
    int * pLeaves;
    int Limit, nLeaves0, nLeaves1;
    int i, k, c;
 
    assert( pCut0->nLeaves >= pCut1->nLeaves );
 
    // consider two cuts
    nLeaves0 = pCut0->nLeaves;
    nLeaves1 = pCut1->nLeaves;
 
    // the case of the largest cut sizes
    Limit = p->pParams->nVarsMax;
    if ( nLeaves0 == Limit && nLeaves1 == Limit )
    {
        for ( i = 0; i < nLeaves0; i++ )
            if ( pCut0->pLeaves[i] != pCut1->pLeaves[i] )
                return NULL;
        pRes = Cut_CutAlloc( p );
        for ( i = 0; i < nLeaves0; i++ )
            pRes->pLeaves[i] = pCut0->pLeaves[i];
        pRes->nLeaves = pCut0->nLeaves;
        return pRes;
    }
    // the case when one of the cuts is the largest
    if ( nLeaves0 == Limit )
    {
        for ( i = 0; i < nLeaves1; i++ )
        {
            for ( k = nLeaves0 - 1; k >= 0; k-- )
                if ( pCut0->pLeaves[k] == pCut1->pLeaves[i] )
                    break;
            if ( k == -1 ) // did not find
                return NULL;
        }
        pRes = Cut_CutAlloc( p );
        for ( i = 0; i < nLeaves0; i++ )
            pRes->pLeaves[i] = pCut0->pLeaves[i];
        pRes->nLeaves = pCut0->nLeaves;
        return pRes;
    }
 
    // prepare the cut
    if ( p->pReady == NULL )
        p->pReady = Cut_CutAlloc( p );
    pLeaves = p->pReady->pLeaves;
 
    // compare two cuts with different numbers
    i = k = 0;
    for ( c = 0; c < Limit; c++ )
    {
        if ( k == nLeaves1 )
        {
            if ( i == nLeaves0 )
            {
                p->pReady->nLeaves = c;
                pRes = p->pReady;  p->pReady = NULL;
                return pRes;
            }
            pLeaves[c] = pCut0->pLeaves[i++];
            continue;
        }
        if ( i == nLeaves0 )
        {
            if ( k == nLeaves1 )
            {
                p->pReady->nLeaves = c;
                pRes = p->pReady;  p->pReady = NULL;
                return pRes;
            }
            pLeaves[c] = pCut1->pLeaves[k++];
            continue;
        }
        if ( pCut0->pLeaves[i] < pCut1->pLeaves[k] )
        {
            pLeaves[c] = pCut0->pLeaves[i++];
            continue;
        }
        if ( pCut0->pLeaves[i] > pCut1->pLeaves[k] )
        {
            pLeaves[c] = pCut1->pLeaves[k++];
            continue;
        }
        pLeaves[c] = pCut0->pLeaves[i++]; 
        k++;
    }
    if ( i < nLeaves0 || k < nLeaves1 )
        return NULL;
    p->pReady->nLeaves = c;
    pRes = p->pReady;  p->pReady = NULL;
    return pRes;
}

Here is the call graph for this function:

Cut_CutNumberList()

void Cut_CutNumberList ( Cut_Cut_t * pList )

extern

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

Synopsis [Sets the number of the cuts in the list.]

Description []

SideEffects []

SeeAlso []

Definition at line 219 of file cutCut.c.

{
    Cut_Cut_t * pCut;
    int i = 0;
    Cut_ListForEachCut( pList, pCut )
        pCut->Num0 = i++;
}

Here is the caller graph for this function:

Cut_CutPrintMerge()

void Cut_CutPrintMerge ( Cut_Cut_t * pCut, Cut_Cut_t * pCut0, Cut_Cut_t * pCut1 )

extern

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

Synopsis [Consider dropping cuts if they are useless by now.]

Description []

SideEffects []

SeeAlso []

Definition at line 326 of file cutCut.c.

{
    printf( "\n" );
    printf( "%d : %5d %5d %5d %5d %5d\n", 
        pCut0->nLeaves, 
        pCut0->nLeaves > 0 ? pCut0->pLeaves[0] : -1, 
        pCut0->nLeaves > 1 ? pCut0->pLeaves[1] : -1, 
        pCut0->nLeaves > 2 ? pCut0->pLeaves[2] : -1, 
        pCut0->nLeaves > 3 ? pCut0->pLeaves[3] : -1, 
        pCut0->nLeaves > 4 ? pCut0->pLeaves[4] : -1
        );
    printf( "%d : %5d %5d %5d %5d %5d\n", 
        pCut1->nLeaves, 
        pCut1->nLeaves > 0 ? pCut1->pLeaves[0] : -1, 
        pCut1->nLeaves > 1 ? pCut1->pLeaves[1] : -1, 
        pCut1->nLeaves > 2 ? pCut1->pLeaves[2] : -1, 
        pCut1->nLeaves > 3 ? pCut1->pLeaves[3] : -1, 
        pCut1->nLeaves > 4 ? pCut1->pLeaves[4] : -1
        );
    if ( pCut == NULL )
        printf( "Cannot merge\n" );
    else
        printf( "%d : %5d %5d %5d %5d %5d\n", 
            pCut->nLeaves, 
            pCut->nLeaves > 0 ? pCut->pLeaves[0] : -1, 
            pCut->nLeaves > 1 ? pCut->pLeaves[1] : -1, 
            pCut->nLeaves > 2 ? pCut->pLeaves[2] : -1, 
            pCut->nLeaves > 3 ? pCut->pLeaves[3] : -1, 
            pCut->nLeaves > 4 ? pCut->pLeaves[4] : -1
            );
}

Cut_CutRecycle()

void Cut_CutRecycle ( Cut_Man_t * p, Cut_Cut_t * pCut )

extern

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

Synopsis [Recybles the cut.]

Description []

SideEffects []

SeeAlso []

Definition at line 72 of file cutCut.c.

{
    p->nCutsDealloc++;
    p->nCutsCur--;
    if ( pCut->nLeaves == 1 )
        p->nCutsTriv--;
    Extra_MmFixedEntryRecycle( p->pMmCuts, (char *)pCut );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Cut_CutRecycleList()

void Cut_CutRecycleList ( Cut_Man_t * p, Cut_Cut_t * pList )

extern

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

Synopsis [Recycles the list.]

Description []

SideEffects []

SeeAlso []

Definition at line 148 of file cutCut.c.

{
    Cut_Cut_t * pCut, * pCut2;
    Cut_ListForEachCutSafe( pList, pCut, pCut2 )
        Extra_MmFixedEntryRecycle( p->pMmCuts, (char *)pCut );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Cut_NodeDoComputeCuts()

void Cut_NodeDoComputeCuts ( Cut_Man_t * p, Cut_List_t * pSuper, int Node, int fCompl0, int fCompl1, Cut_Cut_t * pList0, Cut_Cut_t * pList1, int fTriv, int TreeCode )

extern

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

Synopsis [Computes the cuts by merging cuts at two nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 572 of file cutNode.c.

{
    Cut_Cut_t * pStop0, * pStop1, * pTemp0, * pTemp1;
    Cut_Cut_t * pStore0 = NULL, * pStore1 = NULL; // Suppress "might be used uninitialized"
    int i, nCutsOld, Limit;
    // start with the elementary cut
    if ( fTriv ) 
    {
//        printf( "Creating trivial cut %d.\n", Node );
        pTemp0 = Cut_CutCreateTriv( p, Node );
        Cut_ListAdd( pSuper, pTemp0 );
        p->nNodeCuts++;
    }
    // get the cut lists of children
    if ( pList0 == NULL || pList1 == NULL || (p->pParams->fLocal && TreeCode)  )
        return;
 
    // remember the old number of cuts
    nCutsOld = p->nCutsCur;
    Limit = p->pParams->nVarsMax;
    // get the simultation bit of the node
    p->fSimul = (fCompl0 ^ pList0->fSimul) & (fCompl1 ^ pList1->fSimul);
    // set temporary variables
    p->fCompl0 = fCompl0;
    p->fCompl1 = fCompl1;
    // if tree cuts are computed, make sure only the unit cuts propagate over the DAG nodes
    if ( TreeCode & 1 )
    {
        assert( pList0->nLeaves == 1 );
        pStore0 = pList0->pNext;
        pList0->pNext = NULL;
    }
    if ( TreeCode & 2 )
    {
        assert( pList1->nLeaves == 1 );
        pStore1 = pList1->pNext;
        pList1->pNext = NULL;
    }
    // find the point in the list where the max-var cuts begin
    Cut_ListForEachCut( pList0, pStop0 )
        if ( pStop0->nLeaves == (unsigned)Limit )
            break;
    Cut_ListForEachCut( pList1, pStop1 )
        if ( pStop1->nLeaves == (unsigned)Limit )
            break;
 
    // small by small
    Cut_ListForEachCutStop( pList0, pTemp0, pStop0 )
    Cut_ListForEachCutStop( pList1, pTemp1, pStop1 )
    {
        if ( Cut_CutProcessTwo( p, pTemp0, pTemp1, pSuper ) )
            goto Quits;
    }
    // small by large
    Cut_ListForEachCutStop( pList0, pTemp0, pStop0 )
    Cut_ListForEachCut( pStop1, pTemp1 )
    {
        if ( (pTemp0->uSign & pTemp1->uSign) != pTemp0->uSign )
            continue;
        if ( Cut_CutProcessTwo( p, pTemp0, pTemp1, pSuper ) )
            goto Quits;
    }
    // small by large
    Cut_ListForEachCutStop( pList1, pTemp1, pStop1 )
    Cut_ListForEachCut( pStop0, pTemp0 )
    {
        if ( (pTemp0->uSign & pTemp1->uSign) != pTemp1->uSign )
            continue;
        if ( Cut_CutProcessTwo( p, pTemp0, pTemp1, pSuper ) )
            goto Quits;
    }
    // large by large
    Cut_ListForEachCut( pStop0, pTemp0 )
    Cut_ListForEachCut( pStop1, pTemp1 )
    {
        assert( pTemp0->nLeaves == (unsigned)Limit && pTemp1->nLeaves == (unsigned)Limit );
        if ( pTemp0->uSign != pTemp1->uSign )
            continue;
        for ( i = 0; i < Limit; i++ )
            if ( pTemp0->pLeaves[i] != pTemp1->pLeaves[i] )
                break;
        if ( i < Limit )
            continue;
        if ( Cut_CutProcessTwo( p, pTemp0, pTemp1, pSuper ) )
            goto Quits;
    } 
    if ( p->nNodeCuts == 0 )
        p->nNodesNoCuts++;
Quits:
    if ( TreeCode & 1 )
        pList0->pNext = pStore0;
    if ( TreeCode & 2 )
        pList1->pNext = pStore1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Cut_TableClear()

void Cut_TableClear ( Cut_HashTable_t * pTable )

extern

Cut_TableLookup()

int Cut_TableLookup ( Cut_HashTable_t * pTable, Cut_Cut_t * pCut, int fStore )

extern

Cut_TableReadTime()

int Cut_TableReadTime ( Cut_HashTable_t * pTable )

extern

Cut_TableStart()

Cut_HashTable_t * Cut_TableStart ( int Size )

extern

Cut_TableStop()

void Cut_TableStop ( Cut_HashTable_t * pTable )

extern

Cut_TruthCompute()

void Cut_TruthCompute ( Cut_Man_t * p, Cut_Cut_t * pCut, Cut_Cut_t * pCut0, Cut_Cut_t * pCut1, int fCompl0, int fCompl1 )

extern

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

Synopsis [Performs truth table computation.]

Description []

SideEffects []

SeeAlso []

Definition at line 177 of file cutTruth.c.

{
    // permute the first table
    if ( fCompl0 ) 
        Extra_TruthNot( p->puTemp[0], Cut_CutReadTruth(pCut0), pCut->nVarsMax );
    else
        Extra_TruthCopy( p->puTemp[0], Cut_CutReadTruth(pCut0), pCut->nVarsMax );
    Extra_TruthStretch( p->puTemp[2], p->puTemp[0], pCut0->nLeaves, pCut->nVarsMax, Cut_TruthPhase(pCut, pCut0) );
    // permute the second table
    if ( fCompl1 ) 
        Extra_TruthNot( p->puTemp[1], Cut_CutReadTruth(pCut1), pCut->nVarsMax );
    else
        Extra_TruthCopy( p->puTemp[1], Cut_CutReadTruth(pCut1), pCut->nVarsMax );
    Extra_TruthStretch( p->puTemp[3], p->puTemp[1], pCut1->nLeaves, pCut->nVarsMax, Cut_TruthPhase(pCut, pCut1) );
    // produce the resulting table
    if ( pCut->fCompl )
        Extra_TruthNand( Cut_CutReadTruth(pCut), p->puTemp[2], p->puTemp[3], pCut->nVarsMax );
    else
        Extra_TruthAnd( Cut_CutReadTruth(pCut), p->puTemp[2], p->puTemp[3], pCut->nVarsMax );
 
//    Ivy_TruthTestOne( *Cut_CutReadTruth(pCut) );
 
    // quit if no fancy computation is needed
    if ( !p->pParams->fFancy )
        return;
 
    if ( pCut->nLeaves != 7 )
        return;
 
    // count the total number of truth tables computed
    nTotal++;
 
    // MAPPING INTO ALTERA 6-2 LOGIC BLOCKS
    // call this procedure to find the minimum number of common variables in the cofactors
    // if this number is less or equal than 3, the cut can be implemented using the 6-2 logic block
    if ( Extra_TruthMinCofSuppOverlap( Cut_CutReadTruth(pCut), pCut->nVarsMax, NULL ) <= 4 )
        nGood++;
 
    // MAPPING INTO ACTEL 2x2 CELLS
    // call this procedure to see if a semi-canonical form can be found in the lookup table 
    // (if it exists, then a two-level 3-input LUT implementation of the cut exists)
    // Before this procedure is called, cell manager should be defined by calling
    // Cut_CellLoad (make sure file "cells22_daomap_iwls.txt" is available in the working dir)
//    if ( Cut_CellIsRunning() && pCut->nVarsMax <= 9 )
//        nGood += Cut_CellTruthLookup( Cut_CutReadTruth(pCut), pCut->nVarsMax );
}

Here is the call graph for this function:

Cut_TruthComputeOld()

void Cut_TruthComputeOld ( Cut_Cut_t * pCut, Cut_Cut_t * pCut0, Cut_Cut_t * pCut1, int fCompl0, int fCompl1 )

extern

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

Synopsis [Performs truth table computation.]

Description []

SideEffects []

SeeAlso []

Definition at line 126 of file cutTruth.c.

{
    static unsigned uTruth0[8], uTruth1[8];
    int nTruthWords = Cut_TruthWords( pCut->nVarsMax );
    unsigned * pTruthRes;
    int i, uPhase;
 
    // permute the first table
    uPhase = Cut_TruthPhase( pCut, pCut0 );
    Extra_TruthExpand( pCut->nVarsMax, nTruthWords, Cut_CutReadTruth(pCut0), uPhase, uTruth0 );
    if ( fCompl0 ) 
    {
        for ( i = 0; i < nTruthWords; i++ )
            uTruth0[i] = ~uTruth0[i];
    }
 
    // permute the second table
    uPhase = Cut_TruthPhase( pCut, pCut1 );
    Extra_TruthExpand( pCut->nVarsMax, nTruthWords, Cut_CutReadTruth(pCut1), uPhase, uTruth1 );
    if ( fCompl1 ) 
    {
        for ( i = 0; i < nTruthWords; i++ )
            uTruth1[i] = ~uTruth1[i];
    }
 
    // write the resulting table
    pTruthRes = Cut_CutReadTruth(pCut);
 
    if ( pCut->fCompl )
    {
        for ( i = 0; i < nTruthWords; i++ )
            pTruthRes[i] = ~(uTruth0[i] & uTruth1[i]);
    }
    else
    {
        for ( i = 0; i < nTruthWords; i++ )
            pTruthRes[i] = uTruth0[i] & uTruth1[i];
    }
}

Here is the call graph for this function:

Here is the caller graph for this function: