extrautilprint.c

主要进行大规模的电路综合

/**CFile****************************************************************

  FileName    [extraUtilPrint.c]

  PackageName [extra]

  Synopsis    [Various printing procedures.]

  Author      [Alan Mishchenko]
  
  Affiliation [UC Berkeley]

  Date        [Ver. 1.0. Started - February 1, 2003.]

  Revision    [$Id: extraUtilPrint.c,v 1.2 2003/05/27 23:14:41 alanmi Exp $]

***********************************************************************/

#include "extra.h"

/*---------------------------------------------------------------------------*/
/* Constant declarations                                                     */
/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/
/* Stucture declarations                                                     */
/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/
/* Type declarations                                                         */
/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/
/* Variable declarations                                                     */
/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/
/* Macro declarations                                                        */
/*---------------------------------------------------------------------------*/


/**AutomaticStart*************************************************************/

/*---------------------------------------------------------------------------*/
/* Static function prototypes                                                */
/*---------------------------------------------------------------------------*/

static void extraWriteBlifNode( FILE * pFile, DdManager * dd, DdNode * zCover, int * pVarMap, int nVars, int levPrev, int * pVarValues );
static void extraWriteBlifGateCascade( FILE * pFile, char * pInputNames[], int Polars[], int nInputs, char * pOutputName, int GateType, int OutputSigNum, int * pSigNum );
static void extraWriteBlifNodeUsingGates( FILE * pFile, DdManager * dd, DdNode * zCover, char * pInputNames[], char * pOutputName, int fCascade );

/**AutomaticEnd***************************************************************/

/*---------------------------------------------------------------------------*/
/* Definition of exported functions                                          */
/*---------------------------------------------------------------------------*/

/**Function*************************************************************

  Synopsis    []

  Description []

  SideEffects []

  SeeAlso     []

***********************************************************************/
unsigned Extra_ReadBinary( char * Buffer )
{
	unsigned Result;
	int i;

	Result = 0;
	for ( i = 0; Buffer[i]; i++ )
		if ( Buffer[i] == '0' || Buffer[i] == '1' )
			Result = Result * 2 + Buffer[i] - '0';
		else
		{
			assert( 0 );
		}
	return Result;
}

/**Function*************************************************************

  Synopsis    [Prints the bit string.]

  Description []

  SideEffects []

  SeeAlso     []

***********************************************************************/
void Extra_PrintBinary( FILE * pFile, unsigned Sign[], int nBits )
{
	int Remainder, nWords;
	int w, i;

	Remainder = (nBits%(sizeof(unsigned)*8));
	nWords    = (nBits/(sizeof(unsigned)*8)) + (Remainder>0);

	for ( w = nWords-1; w >= 0; w-- )
		for ( i = ((w == nWords-1)? Remainder-1: 31); i >= 0; i-- )
 			fprintf( pFile, "%c", '0' + (int)((Sign[w] & (1<<i)) > 0) );

//	fprintf( pFile, "\n" );
}

/**Function*************************************************************

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
void Extra_PrintSupport( DdManager * dd, DdNode * Func )
{
	DdNode * bSupp;
	bSupp = Cudd_Support( dd, Func );  Cudd_Ref( bSupp );
PRB( dd, bSupp );
	Cudd_RecursiveDeref( dd, bSupp );
	printf( "\n" );
}

/**Function*************************************************************

  Synopsis    [Returns the composite name of the file.]

  Description []

  SideEffects []

  SeeAlso     []

***********************************************************************/
void Extra_PrintSymbols( FILE * pFile, char Char, int nTimes, int fPrintNewLine )
{
	int i;
	for ( i = 0; i < nTimes; i++ )
		printf( "%c", Char );
	if ( fPrintNewLine )
		printf( "\n" );
}

/**Function*************************************************************

  Synopsis    [Writes the DOT file.]

  Description []

  SideEffects []

  SeeAlso     []

***********************************************************************/
void Extra_DumpDot( DdManager * dd, DdNode * pFuncs[], int nFuncs, char * FileName, int fFlagZdd )
{
	FILE * pFileDot;
    pFileDot = fopen( FileName, "w" );
	if ( fFlagZdd )
		Cudd_zddDumpDot( dd, nFuncs, pFuncs, NULL, NULL, pFileDot );
	else
		Cudd_DumpDot( dd, nFuncs, pFuncs, NULL, NULL, pFileDot );
    fclose( pFileDot );
}


/**Function*************************************************************

  Synopsis    []

  Description []

  SideEffects []

  SeeAlso     []

***********************************************************************/
int Extra_FileNameCheckExtension( char * FileName, char * Extension )
{
	char * pDot;
	// find "dot" if it is present in the file name
	pDot = strstr( FileName, "." );
	if ( pDot && strcmp( pDot+1, Extension ) == 0 )
		return 1;
	else
		return 0;
}

/**Function*************************************************************

  Synopsis    [Returns the composite name of the file.]

  Description []

  SideEffects []

  SeeAlso     []

***********************************************************************/
char * Extra_FileNameAppend( char * pBase, char * pSuffix )
{
	static char Buffer[100];
	sprintf( Buffer, "%s%s", pBase, pSuffix );
	return Buffer;
}

/**Function*************************************************************

  Synopsis    []

  Description []

  SideEffects []

  SeeAlso     []

***********************************************************************/
char * Extra_FileNameGeneric( char * FileName )
{
	char * pDot;
	char * pUnd;
	char * pRes;
	
	// find the generic name of the file
	pRes = util_strsav( FileName );
	// find the pointer to the "." symbol in the file name
//	pUnd = strstr( FileName, "_" );
	pUnd = NULL;
	pDot = strstr( FileName, "." );
	if ( pUnd )
		pRes[pUnd - FileName] = 0;
	else if ( pDot )
		pRes[pDot - FileName] = 0;
	return pRes;
}

/**Function*************************************************************

  Synopsis    []

  Description []

  SideEffects []

  SeeAlso     []

***********************************************************************/
void Extra_StopManager( DdManager * dd )
{
	int RetValue;
	// check for remaining references in the package
	RetValue = Cudd_CheckZeroRef( dd );
	if ( RetValue > 0 )
		printf( "\nThe number of referenced nodes = %d\n\n", RetValue );
//	Cudd_PrintInfo( dd, stdout );
	Cudd_Quit( dd );
}

/**Function*************************************************************

  Synopsis    []

  Description []

  SideEffects []

  SeeAlso     []

***********************************************************************/
int Extra_Power3( int Num )
{
	int i;
	int Res;
	Res = 1;
	for ( i = 0; i < Num; i++ )
		Res *= 3;
	return Res;
}

/**Function*************************************************************

  Synopsis    []

  Description []

  SideEffects []

  SeeAlso     []

***********************************************************************/
int * Extra_DeriveRadixCode( int Number, int Radix, int nDigits )
{
	static int Code[100];
	int i;
	assert( nDigits < 100 );
	for ( i = 0; i < nDigits; i++ )
	{
		Code[i] = Number % Radix;
		Number  = Number / Radix;
	}
	assert( Number == 0 );
	return Code;
}


/**Function*************************************************************

  Synopsis    []

  Description []
  
  SideEffects []

  SeeAlso     []

***********************************************************************/
FILE * Extra_WriteBlifStart( char * FileName, char * pInputNames[], int nInputs, char * pOutputNames[], int nOutputs )
{
	FILE * pFile;
	int i;
	// start writing the output file
	pFile = fopen( FileName, "w" );
	// write the hearder
	fprintf( pFile, ".model %s", FileName );
	fprintf( pFile, "\n" );

	fprintf( pFile, ".inputs" );
	for ( i = 0; i < nInputs; i++ )
		fprintf( pFile, " %s", pInputNames[i] );
	fprintf( pFile, "\n" );

	fprintf( pFile, ".outputs" );
	for ( i = 0; i < nOutputs; i++ )
		fprintf( pFile, " %s", pOutputNames[i] );
	fprintf( pFile, "\n" );
	return pFile;
}

/**Function*************************************************************

  Synopsis    [Write the BDD/ZDD into as the boolean node in the BLIF file.]

  Description [The file and the DD manager are obvious. The manager can 
  be reordered. The function is the BDD in the given manager. The input
  names in the array are all variable names in the manager. The function
  may actually depend on a subset of them. Whether the manager is reordered
  or not, this function always writes the cover in the natural ordering
  of the variables. The output names is used on the ".names" line.
  If the array of variables is not given, the ".names" line is not written.]
  
  SideEffects []

  SeeAlso     []

***********************************************************************/
void Extra_WriteBlifNode( FILE * pFile, DdManager * dd, DdNode * Func, char * pInputNames[], char * pOutputName )
{
	DdNode * zCover;
	int * pVarMap;
	int * pSupport;
	int * pVarValues;
	int nSupp, v;
	int fThisIsBdd;

	pSupport   = ALLOC( int, ddMax(dd->size,dd->sizeZ) );
	pVarMap    = ALLOC( int, ddMax(dd->size,dd->sizeZ) );
	pVarValues = ALLOC( int, ddMax(dd->size,dd->sizeZ) );

	fThisIsBdd = Extra_WithComplementedEdges(Func);

	// derive the mapping of support variables into the real variables of this function
	nSupp = 0;
	Extra_SupportArray( dd, Func, pSupport );
	if ( fThisIsBdd )
	{
		for ( v = 0; v < dd->size; v++ )
			if ( pSupport[v] )
				pVarMap[nSupp++] = v;
	}
	else // this is a ZDD
	{
		for ( v = 0; v < dd->size; v++ )
			if ( pSupport[2*v] || pSupport[2*v+1] )
				pVarMap[nSupp++] = v;
	}


	if ( pInputNames )
	{ 
		// write the ".names" line
		fprintf( pFile, ".names" );
		// write the inputs in the order of increasing variable number
		for ( v = 0; v < nSupp; v++ )
			fprintf( pFile, " %s", pInputNames[pVarMap[v]] );
		// write the output
		fprintf( pFile, "  %s\n", pOutputName );
	}

	// create the ZDD coverk
	if ( fThisIsBdd )
	{
		zCover = Extra_zddIsopCover( dd, Func, Func );  Cudd_Ref( zCover );
	//	zCover = sopEspressoSingle( dd, Func, 1 );  Cudd_Ref( zCover );
		extraWriteBlifNode( pFile, dd, zCover, pVarMap, nSupp, -1, pVarValues );
		Cudd_RecursiveDerefZdd( dd, zCover );
	}
	else
		extraWriteBlifNode( pFile, dd, Func, pVarMap, nSupp, -1, pVarValues );

	free( pSupport );
	free( pVarMap );
	free( pVarValues );
}


/**Function*************************************************************

  Synopsis    [Write the BDD/ZDD into as the boolean node using two-input AND/OR gates.]

  Description []
  
  SideEffects []

  SeeAlso     []

***********************************************************************/
void Extra_WriteBlifNodeUsingGates( FILE * pFile, DdManager * dd, DdNode * Func, char * pInputNames[], char * pOutputName, int fCascade )
{
	DdNode * zCover;
	// create the ZDD cover
	if ( Extra_WithComplementedEdges(Func) )
	{
		zCover = Extra_zddIsopCover( dd, Func, Func );  Cudd_Ref( zCover );
		extraWriteBlifNodeUsingGates( pFile, dd, zCover, pInputNames, pOutputName, fCascade );
		Cudd_RecursiveDerefZdd( dd, zCover );
	}
	else
		extraWriteBlifNodeUsingGates( pFile, dd, Func, pInputNames, pOutputName, fCascade );
}


/**Function*************************************************************