From e54d9691616b9a0326e2fdb3156bb4eeb8abfcd7 Mon Sep 17 00:00:00 2001 From: Alan Mishchenko Date: Sun, 30 Sep 2007 08:01:00 -0700 Subject: Version abc70930 --- src/map/mapper/mapper.c | 176 ------ src/map/mapper/mapper.h | 195 ------- src/map/mapper/mapperCanon.c | 271 --------- src/map/mapper/mapperCore.c | 228 -------- src/map/mapper/mapperCreate.c | 600 -------------------- src/map/mapper/mapperCut.c | 1168 --------------------------------------- src/map/mapper/mapperCutUtils.c | 273 --------- src/map/mapper/mapperFanout.c | 141 ----- src/map/mapper/mapperGENERIC.c | 46 -- src/map/mapper/mapperInt.h | 477 ---------------- src/map/mapper/mapperLib.c | 231 -------- src/map/mapper/mapperMatch.c | 596 -------------------- src/map/mapper/mapperRefs.c | 557 ------------------- src/map/mapper/mapperSuper.c | 449 --------------- src/map/mapper/mapperSwitch.c | 223 -------- src/map/mapper/mapperTable.c | 402 -------------- src/map/mapper/mapperTime.c | 510 ----------------- src/map/mapper/mapperTree.c | 818 --------------------------- src/map/mapper/mapperTruth.c | 310 ----------- src/map/mapper/mapperUtils.c | 1154 -------------------------------------- src/map/mapper/mapperVec.c | 318 ----------- src/map/mapper/module.make | 18 - 22 files changed, 9161 deletions(-) delete mode 100644 src/map/mapper/mapper.c delete mode 100644 src/map/mapper/mapper.h delete mode 100644 src/map/mapper/mapperCanon.c delete mode 100644 src/map/mapper/mapperCore.c delete mode 100644 src/map/mapper/mapperCreate.c delete mode 100644 src/map/mapper/mapperCut.c delete mode 100644 src/map/mapper/mapperCutUtils.c delete mode 100644 src/map/mapper/mapperFanout.c delete mode 100644 src/map/mapper/mapperGENERIC.c delete mode 100644 src/map/mapper/mapperInt.h delete mode 100644 src/map/mapper/mapperLib.c delete mode 100644 src/map/mapper/mapperMatch.c delete mode 100644 src/map/mapper/mapperRefs.c delete mode 100644 src/map/mapper/mapperSuper.c delete mode 100644 src/map/mapper/mapperSwitch.c delete mode 100644 src/map/mapper/mapperTable.c delete mode 100644 src/map/mapper/mapperTime.c delete mode 100644 src/map/mapper/mapperTree.c delete mode 100644 src/map/mapper/mapperTruth.c delete mode 100644 src/map/mapper/mapperUtils.c delete mode 100644 src/map/mapper/mapperVec.c delete mode 100644 src/map/mapper/module.make (limited to 'src/map/mapper') diff --git a/src/map/mapper/mapper.c b/src/map/mapper/mapper.c deleted file mode 100644 index b18b68c0..00000000 --- a/src/map/mapper/mapper.c +++ /dev/null @@ -1,176 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapper.c] - - PackageName [MVSIS 1.3: Multi-valued logic synthesis system.] - - Synopsis [Command file for the mapper package.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 2.0. Started - June 1, 2004.] - - Revision [$Id: mapper.c,v 1.7 2005/01/23 06:59:42 alanmi Exp $] - -***********************************************************************/ - -#include "abc.h" -#include "mainInt.h" -#include "mio.h" -#include "mapperInt.h" - -//////////////////////////////////////////////////////////////////////// -/// DECLARATIONS /// -//////////////////////////////////////////////////////////////////////// - -static int Map_CommandReadLibrary ( Abc_Frame_t * pAbc, int argc, char **argv ); - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_Init( Abc_Frame_t * pAbc ) -{ - Cmd_CommandAdd( pAbc, "SC mapping", "read_super", Map_CommandReadLibrary, 0 ); -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_End() -{ -// Map_SuperLibFree( s_pSuperLib ); - Map_SuperLibFree( Abc_FrameReadLibSuper() ); -} - - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_CommandReadLibrary( Abc_Frame_t * pAbc, int argc, char **argv ) -{ - FILE * pFile; - FILE * pOut, * pErr; - Map_SuperLib_t * pLib; - Abc_Ntk_t * pNet; - char * FileName, * ExcludeFile; - int fVerbose; - int fAlgorithm; - int c; - - pNet = Abc_FrameReadNtk(pAbc); - pOut = Abc_FrameReadOut(pAbc); - pErr = Abc_FrameReadErr(pAbc); - - // set the defaults - fVerbose = 1; - fAlgorithm = 1; - ExcludeFile = 0; - Extra_UtilGetoptReset(); - while ( (c = Extra_UtilGetopt(argc, argv, "eovh")) != EOF ) - { - switch (c) - { - case 'e': - ExcludeFile = argv[globalUtilOptind]; - if ( ExcludeFile == 0 ) - goto usage; - globalUtilOptind++; - break; - case 'o': - fAlgorithm ^= 1; - break; - case 'v': - fVerbose ^= 1; - break; - case 'h': - goto usage; - break; - default: - goto usage; - } - } - - - if ( argc != globalUtilOptind + 1 ) - { - goto usage; - } - - // get the input file name - FileName = argv[globalUtilOptind]; - if ( (pFile = Io_FileOpen( FileName, "open_path", "r", 0 )) == NULL ) -// if ( (pFile = fopen( FileName, "r" )) == NULL ) - { - fprintf( pErr, "Cannot open input file \"%s\". ", FileName ); - if ( FileName = Extra_FileGetSimilarName( FileName, ".genlib", ".lib", ".gen", ".g", NULL ) ) - fprintf( pErr, "Did you mean \"%s\"?", FileName ); - fprintf( pErr, "\n" ); - return 1; - } - fclose( pFile ); - - // set the new network - pLib = Map_SuperLibCreate( FileName, ExcludeFile, fAlgorithm, fVerbose ); - if ( pLib == NULL ) - { - fprintf( pErr, "Reading supergate library has failed.\n" ); - goto usage; - } - // replace the current library -// Map_SuperLibFree( s_pSuperLib ); -// s_pSuperLib = pLib; - Map_SuperLibFree( Abc_FrameReadLibSuper() ); - Abc_FrameSetLibSuper( pLib ); - // replace the current genlib library -// if ( s_pLib ) Mio_LibraryDelete( s_pLib ); -// s_pLib = s_pSuperLib->pGenlib; - Mio_LibraryDelete( Abc_FrameReadLibGen() ); - Abc_FrameSetLibGen( pLib->pGenlib ); - return 0; - -usage: - fprintf( pErr, "\nusage: read_super [-ovh]\n"); - fprintf( pErr, "\t read the supergate library from the file\n" ); - fprintf( pErr, "\t-e file : file contains list of genlib gates to exclude\n" ); - fprintf( pErr, "\t-o : toggles the use of old file format [default = %s]\n", (fAlgorithm? "new" : "old") ); - fprintf( pErr, "\t-v : toggles enabling of verbose output [default = %s]\n", (fVerbose? "yes" : "no") ); - fprintf( pErr, "\t-h : print the command usage\n"); - return 1; /* error exit */ -} - - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - - diff --git a/src/map/mapper/mapper.h b/src/map/mapper/mapper.h deleted file mode 100644 index 8eade761..00000000 --- a/src/map/mapper/mapper.h +++ /dev/null @@ -1,195 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapper.h] - - PackageName [MVSIS 2.0: Multi-valued logic synthesis system.] - - Synopsis [Generic technology mapping engine.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 2.0. Started - June 1, 2004.] - - Revision [$Id: mapper.h,v 1.11 2005/02/28 05:34:26 alanmi Exp $] - -***********************************************************************/ - -#ifndef __MAPPER_H__ -#define __MAPPER_H__ - -#ifdef __cplusplus -extern "C" { -#endif - -//////////////////////////////////////////////////////////////////////// -/// INCLUDES /// -//////////////////////////////////////////////////////////////////////// - - -//////////////////////////////////////////////////////////////////////// -/// PARAMETERS /// -//////////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////////// -/// STRUCTURE DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -typedef struct Map_ManStruct_t_ Map_Man_t; -typedef struct Map_NodeStruct_t_ Map_Node_t; -typedef struct Map_NodeVecStruct_t_ Map_NodeVec_t; -typedef struct Map_CutStruct_t_ Map_Cut_t; -typedef struct Map_MatchStruct_t_ Map_Match_t; -typedef struct Map_SuperStruct_t_ Map_Super_t; -typedef struct Map_SuperLibStruct_t_ Map_SuperLib_t; -typedef struct Map_HashTableStruct_t_ Map_HashTable_t; -typedef struct Map_HashEntryStruct_t_ Map_HashEntry_t; -typedef struct Map_TimeStruct_t_ Map_Time_t; - -// the pair of rise/fall time parameters -struct Map_TimeStruct_t_ -{ - float Rise; - float Fall; - float Worst; -}; - -//////////////////////////////////////////////////////////////////////// -/// GLOBAL VARIABLES /// -//////////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////////// -/// MACRO DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -#define Map_IsComplement(p) (((int)((unsigned long) (p) & 01))) -#define Map_Regular(p) ((Map_Node_t *)((unsigned long)(p) & ~01)) -#define Map_Not(p) ((Map_Node_t *)((unsigned long)(p) ^ 01)) -#define Map_NotCond(p,c) ((Map_Node_t *)((unsigned long)(p) ^ (c))) - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/*=== mapperCreate.c =============================================================*/ -extern Map_Man_t * Map_ManCreate( int nInputs, int nOutputs, int fVerbose ); -extern Map_Node_t * Map_NodeCreate( Map_Man_t * p, Map_Node_t * p1, Map_Node_t * p2 ); -extern void Map_ManFree( Map_Man_t * pMan ); -extern void Map_ManPrintTimeStats( Map_Man_t * p ); -extern void Map_ManPrintStatsToFile( char * pName, float Area, float Delay, int Time ); -extern int Map_ManReadInputNum( Map_Man_t * p ); -extern int Map_ManReadOutputNum( Map_Man_t * p ); -extern Map_Node_t ** Map_ManReadInputs ( Map_Man_t * p ); -extern Map_Node_t ** Map_ManReadOutputs( Map_Man_t * p ); -extern Map_Node_t * Map_ManReadConst1 ( Map_Man_t * p ); -extern Map_Time_t * Map_ManReadInputArrivals( Map_Man_t * p ); -extern Mio_Library_t * Map_ManReadGenLib ( Map_Man_t * p ); -extern bool Map_ManReadVerbose( Map_Man_t * p ); -extern float Map_ManReadAreaFinal( Map_Man_t * p ); -extern float Map_ManReadRequiredGlo( Map_Man_t * p ); -extern void Map_ManSetTimeToMap( Map_Man_t * p, int Time ); -extern void Map_ManSetTimeToNet( Map_Man_t * p, int Time ); -extern void Map_ManSetTimeSweep( Map_Man_t * p, int Time ); -extern void Map_ManSetTimeTotal( Map_Man_t * p, int Time ); -extern void Map_ManSetOutputNames( Map_Man_t * p, char ** ppNames ); -extern void Map_ManSetAreaRecovery( Map_Man_t * p, int fAreaRecovery ); -extern void Map_ManSetDelayTarget( Map_Man_t * p, float DelayTarget ); -extern void Map_ManSetInputArrivals( Map_Man_t * p, Map_Time_t * pArrivals ); -extern void Map_ManSetObeyFanoutLimits( Map_Man_t * p, bool fObeyFanoutLimits ); -extern void Map_ManSetNumIterations( Map_Man_t * p, int nNumIterations ); -extern int Map_ManReadPass( Map_Man_t * p ); -extern void Map_ManSetPass( Map_Man_t * p, int nPass ); -extern int Map_ManReadFanoutViolations( Map_Man_t * p ); -extern void Map_ManSetFanoutViolations( Map_Man_t * p, int nVio ); -extern void Map_ManSetChoiceNodeNum( Map_Man_t * p, int nChoiceNodes ); -extern void Map_ManSetChoiceNum( Map_Man_t * p, int nChoices ); -extern void Map_ManSetVerbose( Map_Man_t * p, int fVerbose ); -extern void Map_ManSetSwitching( Map_Man_t * p, int fSwitching ); - -extern Map_Man_t * Map_NodeReadMan( Map_Node_t * p ); -extern char * Map_NodeReadData( Map_Node_t * p, int fPhase ); -extern int Map_NodeReadNum( Map_Node_t * p ); -extern int Map_NodeReadLevel( Map_Node_t * p ); -extern Map_Cut_t * Map_NodeReadCuts( Map_Node_t * p ); -extern Map_Cut_t * Map_NodeReadCutBest( Map_Node_t * p, int fPhase ); -extern Map_Node_t * Map_NodeReadOne( Map_Node_t * p ); -extern Map_Node_t * Map_NodeReadTwo( Map_Node_t * p ); -extern void Map_NodeSetData( Map_Node_t * p, int fPhase, char * pData ); -extern void Map_NodeSetNextE( Map_Node_t * p, Map_Node_t * pNextE ); -extern void Map_NodeSetRepr( Map_Node_t * p, Map_Node_t * pRepr ); -extern void Map_NodeSetSwitching( Map_Node_t * p, float Switching ); - -extern int Map_NodeIsConst( Map_Node_t * p ); -extern int Map_NodeIsVar( Map_Node_t * p ); -extern int Map_NodeIsAnd( Map_Node_t * p ); -extern int Map_NodeComparePhase( Map_Node_t * p1, Map_Node_t * p2 ); - -extern Map_Super_t * Map_CutReadSuperBest( Map_Cut_t * p, int fPhase ); -extern Map_Super_t * Map_CutReadSuper0( Map_Cut_t * p ); -extern Map_Super_t * Map_CutReadSuper1( Map_Cut_t * p ); -extern int Map_CutReadLeavesNum( Map_Cut_t * p ); -extern Map_Node_t ** Map_CutReadLeaves( Map_Cut_t * p ); -extern unsigned Map_CutReadPhaseBest( Map_Cut_t * p, int fPhase ); -extern unsigned Map_CutReadPhase0( Map_Cut_t * p ); -extern unsigned Map_CutReadPhase1( Map_Cut_t * p ); -extern Map_Cut_t * Map_CutReadNext( Map_Cut_t * p ); - -extern char * Map_SuperReadFormula( Map_Super_t * p ); -extern Mio_Gate_t * Map_SuperReadRoot( Map_Super_t * p ); -extern int Map_SuperReadNum( Map_Super_t * p ); -extern Map_Super_t ** Map_SuperReadFanins( Map_Super_t * p ); -extern int Map_SuperReadFaninNum( Map_Super_t * p ); -extern Map_Super_t * Map_SuperReadNext( Map_Super_t * p ); -extern int Map_SuperReadNumPhases( Map_Super_t * p ); -extern unsigned char * Map_SuperReadPhases( Map_Super_t * p ); -extern int Map_SuperReadFanoutLimit( Map_Super_t * p ); - -extern Mio_Library_t * Map_SuperLibReadGenLib( Map_SuperLib_t * p ); -extern float Map_SuperLibReadAreaInv( Map_SuperLib_t * p ); -extern Map_Time_t Map_SuperLibReadDelayInv( Map_SuperLib_t * p ); -extern int Map_SuperLibReadVarsMax( Map_SuperLib_t * p ); - -extern Map_Node_t * Map_NodeAnd( Map_Man_t * p, Map_Node_t * p1, Map_Node_t * p2 ); -extern Map_Node_t * Map_NodeOr( Map_Man_t * p, Map_Node_t * p1, Map_Node_t * p2 ); -extern Map_Node_t * Map_NodeExor( Map_Man_t * p, Map_Node_t * p1, Map_Node_t * p2 ); -extern Map_Node_t * Map_NodeMux( Map_Man_t * p, Map_Node_t * pNode, Map_Node_t * pNodeT, Map_Node_t * pNodeE ); -extern void Map_NodeSetChoice( Map_Man_t * pMan, Map_Node_t * pNodeOld, Map_Node_t * pNodeNew ); - -/*=== resmCanon.c =============================================================*/ -extern int Map_CanonComputeSlow( unsigned uTruths[][2], int nVarsMax, int nVarsReal, unsigned uTruth[], unsigned char * puPhases, unsigned uTruthRes[] ); -extern int Map_CanonComputeFast( Map_Man_t * p, int nVarsMax, int nVarsReal, unsigned uTruth[], unsigned char * puPhases, unsigned uTruthRes[] ); -/*=== mapperCut.c =============================================================*/ -extern Map_Cut_t * Map_CutAlloc( Map_Man_t * p ); -/*=== mapperCutUtils.c =============================================================*/ -extern void Map_CutCreateFromNode( Map_Man_t * p, Map_Super_t * pSuper, int iRoot, unsigned uPhaseRoot, - int * pLeaves, int nLeaves, unsigned uPhaseLeaves ); -/*=== mapperCore.c =============================================================*/ -extern int Map_Mapping( Map_Man_t * p ); -/*=== mapperLib.c =============================================================*/ -extern int Map_SuperLibDeriveFromGenlib( Mio_Library_t * pLib ); -/*=== mapperMntk.c =============================================================*/ -//extern Mntk_Man_t * Map_ConvertMappingToMntk( Map_Man_t * pMan ); -/*=== mapperSuper.c =============================================================*/ -extern char * Map_LibraryReadFormulaStep( char * pFormula, char * pStrings[], int * pnStrings ); -/*=== mapperSweep.c =============================================================*/ -extern void Map_NetworkSweep( Abc_Ntk_t * pNet ); -/*=== mapperTable.c =============================================================*/ -extern Map_Super_t * Map_SuperTableLookupC( Map_SuperLib_t * pLib, unsigned uTruth[] ); -/*=== mapperTime.c =============================================================*/ -/*=== mapperUtil.c =============================================================*/ -extern int Map_ManCheckConsistency( Map_Man_t * p ); -extern st_table * Map_CreateTableGate2Super( Map_Man_t * p ); -extern void Map_ManCleanData( Map_Man_t * p ); -extern void Map_MappingSetupTruthTables( unsigned uTruths[][2] ); -extern void Map_MappingSetupTruthTablesLarge( unsigned uTruths[][32] ); - -#ifdef __cplusplus -} -#endif - -#endif - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// diff --git a/src/map/mapper/mapperCanon.c b/src/map/mapper/mapperCanon.c deleted file mode 100644 index 203c9142..00000000 --- a/src/map/mapper/mapperCanon.c +++ /dev/null @@ -1,271 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapperCanon.c] - - PackageName [MVSIS 1.3: Multi-valued logic synthesis system.] - - Synopsis [Generic technology mapping engine.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 2.0. Started - June 1, 2004.] - - Revision [$Id: mapperCanon.c,v 1.2 2005/01/23 06:59:42 alanmi Exp $] - -***********************************************************************/ - -#include "mapperInt.h" - -//////////////////////////////////////////////////////////////////////// -/// DECLARATIONS /// -//////////////////////////////////////////////////////////////////////// - -static unsigned Map_CanonComputePhase( unsigned uTruths[][2], int nVars, unsigned uTruth, unsigned uPhase ); -static void Map_CanonComputePhase6( unsigned uTruths[][2], int nVars, unsigned uTruth[], unsigned uPhase, unsigned uTruthRes[] ); - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**Function************************************************************* - - Synopsis [Computes the N-canonical form of the Boolean function.] - - Description [The N-canonical form is defined as the truth table with - the minimum integer value. This function exhaustively enumerates - through the complete set of 2^N phase assignments.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_CanonComputeSlow( unsigned uTruths[][2], int nVarsMax, int nVarsReal, unsigned uTruth[], unsigned char * puPhases, unsigned uTruthRes[] ) -{ - unsigned uTruthPerm[2]; - int nMints, nPhases, m; - - nPhases = 0; - nMints = (1 << nVarsReal); - if ( nVarsMax < 6 ) - { - uTruthRes[0] = MAP_MASK(32); - for ( m = 0; m < nMints; m++ ) - { - uTruthPerm[0] = Map_CanonComputePhase( uTruths, nVarsMax, uTruth[0], m ); - if ( uTruthRes[0] > uTruthPerm[0] ) - { - uTruthRes[0] = uTruthPerm[0]; - nPhases = 0; - puPhases[nPhases++] = (unsigned char)m; - } - else if ( uTruthRes[0] == uTruthPerm[0] ) - { - if ( nPhases < 4 ) // the max number of phases in Map_Super_t - puPhases[nPhases++] = (unsigned char)m; - } - } - uTruthRes[1] = uTruthRes[0]; - } - else - { - uTruthRes[0] = MAP_MASK(32); - uTruthRes[1] = MAP_MASK(32); - for ( m = 0; m < nMints; m++ ) - { - Map_CanonComputePhase6( uTruths, nVarsMax, uTruth, m, uTruthPerm ); - if ( uTruthRes[1] > uTruthPerm[1] || uTruthRes[1] == uTruthPerm[1] && uTruthRes[0] > uTruthPerm[0] ) - { - uTruthRes[0] = uTruthPerm[0]; - uTruthRes[1] = uTruthPerm[1]; - nPhases = 0; - puPhases[nPhases++] = (unsigned char)m; - } - else if ( uTruthRes[1] == uTruthPerm[1] && uTruthRes[0] == uTruthPerm[0] ) - { - if ( nPhases < 4 ) // the max number of phases in Map_Super_t - puPhases[nPhases++] = (unsigned char)m; - } - } - } - assert( nPhases > 0 ); -// printf( "%d ", nPhases ); - return nPhases; -} - -/**Function************************************************************* - - Synopsis [Performs phase transformation for one function of less than 6 variables.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -unsigned Map_CanonComputePhase( unsigned uTruths[][2], int nVars, unsigned uTruth, unsigned uPhase ) -{ - int v, Shift; - for ( v = 0, Shift = 1; v < nVars; v++, Shift <<= 1 ) - if ( uPhase & Shift ) - uTruth = (((uTruth & ~uTruths[v][0]) << Shift) | ((uTruth & uTruths[v][0]) >> Shift)); - return uTruth; -} - -/**Function************************************************************* - - Synopsis [Performs phase transformation for one function of 6 variables.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_CanonComputePhase6( unsigned uTruths[][2], int nVars, unsigned uTruth[], unsigned uPhase, unsigned uTruthRes[] ) -{ - unsigned uTemp; - int v, Shift; - - // initialize the result - uTruthRes[0] = uTruth[0]; - uTruthRes[1] = uTruth[1]; - if ( uPhase == 0 ) - return; - // compute the phase - for ( v = 0, Shift = 1; v < nVars; v++, Shift <<= 1 ) - if ( uPhase & Shift ) - { - if ( Shift < 32 ) - { - uTruthRes[0] = (((uTruthRes[0] & ~uTruths[v][0]) << Shift) | ((uTruthRes[0] & uTruths[v][0]) >> Shift)); - uTruthRes[1] = (((uTruthRes[1] & ~uTruths[v][1]) << Shift) | ((uTruthRes[1] & uTruths[v][1]) >> Shift)); - } - else - { - uTemp = uTruthRes[0]; - uTruthRes[0] = uTruthRes[1]; - uTruthRes[1] = uTemp; - } - } -} - -/**Function************************************************************* - - Synopsis [Computes the N-canonical form of the Boolean function.] - - Description [The N-canonical form is defined as the truth table with - the minimum integer value. This function exhaustively enumerates - through the complete set of 2^N phase assignments.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_CanonComputeFast( Map_Man_t * p, int nVarsMax, int nVarsReal, unsigned uTruth[], unsigned char * puPhases, unsigned uTruthRes[] ) -{ - unsigned uTruth0, uTruth1; - unsigned uCanon0, uCanon1, uCanonBest, uPhaseBest; - int i, Limit; - - if ( nVarsMax == 6 ) - return Map_CanonComputeSlow( p->uTruths, nVarsMax, nVarsReal, uTruth, puPhases, uTruthRes ); - - if ( nVarsReal < 5 ) - { -// return Map_CanonComputeSlow( p->uTruths, nVarsMax, nVarsReal, uTruth, puPhases, uTruthRes ); - - uTruth0 = uTruth[0] & 0xFFFF; - assert( p->pCounters[uTruth0] > 0 ); - uTruthRes[0] = (p->uCanons[uTruth0] << 16) | p->uCanons[uTruth0]; - uTruthRes[1] = uTruthRes[0]; - puPhases[0] = p->uPhases[uTruth0][0]; - return 1; - } - - assert( nVarsMax == 5 ); - assert( nVarsReal == 5 ); - uTruth0 = uTruth[0] & 0xFFFF; - uTruth1 = (uTruth[0] >> 16); - if ( uTruth1 == 0 ) - { - uTruthRes[0] = p->uCanons[uTruth0]; - uTruthRes[1] = uTruthRes[0]; - Limit = (p->pCounters[uTruth0] > 4)? 4 : p->pCounters[uTruth0]; - for ( i = 0; i < Limit; i++ ) - puPhases[i] = p->uPhases[uTruth0][i]; - return Limit; - } - else if ( uTruth0 == 0 ) - { - uTruthRes[0] = p->uCanons[uTruth1]; - uTruthRes[1] = uTruthRes[0]; - Limit = (p->pCounters[uTruth1] > 4)? 4 : p->pCounters[uTruth1]; - for ( i = 0; i < Limit; i++ ) - { - puPhases[i] = p->uPhases[uTruth1][i]; - puPhases[i] |= (1 << 4); - } - return Limit; - } - uCanon0 = p->uCanons[uTruth0]; - uCanon1 = p->uCanons[uTruth1]; - if ( uCanon0 >= uCanon1 ) // using nCanon1 as the main one - { - assert( p->pCounters[uTruth1] > 0 ); - uCanonBest = 0xFFFFFFFF; - for ( i = 0; i < p->pCounters[uTruth1]; i++ ) - { - uCanon0 = Extra_TruthPolarize( uTruth0, p->uPhases[uTruth1][i], 4 ); - if ( uCanonBest > uCanon0 ) - { - uCanonBest = uCanon0; - uPhaseBest = p->uPhases[uTruth1][i]; - assert( uPhaseBest < 16 ); - } - } - uTruthRes[0] = (uCanon1 << 16) | uCanonBest; - uTruthRes[1] = uTruthRes[0]; - puPhases[0] = uPhaseBest; - return 1; - } - else if ( uCanon0 < uCanon1 ) - { - assert( p->pCounters[uTruth0] > 0 ); - uCanonBest = 0xFFFFFFFF; - for ( i = 0; i < p->pCounters[uTruth0]; i++ ) - { - uCanon1 = Extra_TruthPolarize( uTruth1, p->uPhases[uTruth0][i], 4 ); - if ( uCanonBest > uCanon1 ) - { - uCanonBest = uCanon1; - uPhaseBest = p->uPhases[uTruth0][i]; - assert( uPhaseBest < 16 ); - } - } - uTruthRes[0] = (uCanon0 << 16) | uCanonBest; - uTruthRes[1] = uTruthRes[0]; - puPhases[0] = uPhaseBest | (1 << 4); - return 1; - } - else - { - assert( 0 ); - return Map_CanonComputeSlow( p->uTruths, nVarsMax, nVarsReal, uTruth, puPhases, uTruthRes ); - } -} - - - - - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - - diff --git a/src/map/mapper/mapperCore.c b/src/map/mapper/mapperCore.c deleted file mode 100644 index 5d4854e6..00000000 --- a/src/map/mapper/mapperCore.c +++ /dev/null @@ -1,228 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapperCore.c] - - PackageName [MVSIS 1.3: Multi-valued logic synthesis system.] - - Synopsis [Generic technology mapping engine.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 2.0. Started - June 1, 2004.] - - Revision [$Id: mapperCore.c,v 1.7 2004/10/01 23:41:04 satrajit Exp $] - -***********************************************************************/ - -#include "mapperInt.h" -//#include "resm.h" - -//////////////////////////////////////////////////////////////////////// -/// DECLARATIONS /// -//////////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**Function************************************************************* - - Synopsis [Performs technology mapping for the given object graph.] - - Description [The object graph is stored in the mapping manager. - First, the AND nodes that fanout into POs are collected in the DFS order. - Two preprocessing steps are performed: the k-feasible cuts are computed - for each node and the truth tables are computed for each cut. Next, the - delay-optimal matches are assigned for each node, followed by several - iterations of area recoveryd: using area flow (global optimization) - and using exact area at a node (local optimization).] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_Mapping( Map_Man_t * p ) -{ - int fShowSwitching = 1; - int fUseAreaFlow = 1; - int fUseExactArea = !p->fSwitching; - int fUseExactAreaWithPhase = !p->fSwitching; - int clk; - - ////////////////////////////////////////////////////////////////////// - // perform pre-mapping computations - // collect the nodes reachable from POs in the DFS order (including the choices) - p->vAnds = Map_MappingDfs( p, 1 ); - if ( p->fVerbose ) - Map_MappingReportChoices( p ); - Map_MappingSetChoiceLevels( p ); // should always be called before mapping! -// return 1; - - // compute the cuts of nodes in the DFS order - clk = clock(); - Map_MappingCuts( p ); - p->timeCuts = clock() - clk; - // derive the truth tables - clk = clock(); - Map_MappingTruths( p ); - p->timeTruth = clock() - clk; - ////////////////////////////////////////////////////////////////////// -//PRT( "Truths", clock() - clk ); - - ////////////////////////////////////////////////////////////////////// - // compute the minimum-delay mapping - clk = clock(); - p->fMappingMode = 0; - if ( !Map_MappingMatches( p ) ) - return 0; - p->timeMatch = clock() - clk; - // compute the references and collect the nodes used in the mapping - Map_MappingSetRefs( p ); - p->AreaBase = Map_MappingGetArea( p, p->vMapping ); -if ( p->fVerbose ) -{ -printf( "Delay : %s = %8.2f Flow = %11.1f Area = %11.1f %4.1f %% ", - fShowSwitching? "Switch" : "Delay", - fShowSwitching? Map_MappingGetSwitching(p,p->vMapping) : p->fRequiredGlo, - Map_MappingGetAreaFlow(p), p->AreaBase, 0.0 ); -PRT( "Time", p->timeMatch ); -} - ////////////////////////////////////////////////////////////////////// - - if ( !p->fAreaRecovery ) - { - if ( p->fVerbose ) - Map_MappingPrintOutputArrivals( p ); - return 1; - } - - ////////////////////////////////////////////////////////////////////// - // perform area recovery using area flow - clk = clock(); - if ( fUseAreaFlow ) - { - // compute the required times - Map_TimeComputeRequiredGlobal( p ); - // recover area flow - p->fMappingMode = 1; - Map_MappingMatches( p ); - // compute the references and collect the nodes used in the mapping - Map_MappingSetRefs( p ); - p->AreaFinal = Map_MappingGetArea( p, p->vMapping ); -if ( p->fVerbose ) -{ -printf( "AreaFlow : %s = %8.2f Flow = %11.1f Area = %11.1f %4.1f %% ", - fShowSwitching? "Switch" : "Delay", - fShowSwitching? Map_MappingGetSwitching(p,p->vMapping) : p->fRequiredGlo, - Map_MappingGetAreaFlow(p), p->AreaFinal, - 100.0*(p->AreaBase-p->AreaFinal)/p->AreaBase ); -PRT( "Time", clock() - clk ); -} - } - p->timeArea += clock() - clk; - ////////////////////////////////////////////////////////////////////// - - ////////////////////////////////////////////////////////////////////// - // perform area recovery using exact area - clk = clock(); - if ( fUseExactArea ) - { - // compute the required times - Map_TimeComputeRequiredGlobal( p ); - // recover area - p->fMappingMode = 2; - Map_MappingMatches( p ); - // compute the references and collect the nodes used in the mapping - Map_MappingSetRefs( p ); - p->AreaFinal = Map_MappingGetArea( p, p->vMapping ); -if ( p->fVerbose ) -{ -printf( "Area : %s = %8.2f Flow = %11.1f Area = %11.1f %4.1f %% ", - fShowSwitching? "Switch" : "Delay", - fShowSwitching? Map_MappingGetSwitching(p,p->vMapping) : p->fRequiredGlo, - 0.0, p->AreaFinal, - 100.0*(p->AreaBase-p->AreaFinal)/p->AreaBase ); -PRT( "Time", clock() - clk ); -} - } - p->timeArea += clock() - clk; - ////////////////////////////////////////////////////////////////////// - - ////////////////////////////////////////////////////////////////////// - // perform area recovery using exact area - clk = clock(); - if ( fUseExactAreaWithPhase ) - { - // compute the required times - Map_TimeComputeRequiredGlobal( p ); - // recover area - p->fMappingMode = 3; - Map_MappingMatches( p ); - // compute the references and collect the nodes used in the mapping - Map_MappingSetRefs( p ); - p->AreaFinal = Map_MappingGetArea( p, p->vMapping ); -if ( p->fVerbose ) -{ -printf( "Area : %s = %8.2f Flow = %11.1f Area = %11.1f %4.1f %% ", - fShowSwitching? "Switch" : "Delay", - fShowSwitching? Map_MappingGetSwitching(p,p->vMapping) : p->fRequiredGlo, - 0.0, p->AreaFinal, - 100.0*(p->AreaBase-p->AreaFinal)/p->AreaBase ); -PRT( "Time", clock() - clk ); -} - } - p->timeArea += clock() - clk; - ////////////////////////////////////////////////////////////////////// - - ////////////////////////////////////////////////////////////////////// - // perform area recovery using exact area - clk = clock(); - if ( p->fSwitching ) - { - // compute the required times - Map_TimeComputeRequiredGlobal( p ); - // recover switching activity - p->fMappingMode = 4; - Map_MappingMatches( p ); - // compute the references and collect the nodes used in the mapping - Map_MappingSetRefs( p ); - p->AreaFinal = Map_MappingGetArea( p, p->vMapping ); -if ( p->fVerbose ) -{ -printf( "Switching: %s = %8.2f Flow = %11.1f Area = %11.1f %4.1f %% ", - fShowSwitching? "Switch" : "Delay", - fShowSwitching? Map_MappingGetSwitching(p,p->vMapping) : p->fRequiredGlo, - 0.0, p->AreaFinal, - 100.0*(p->AreaBase-p->AreaFinal)/p->AreaBase ); -PRT( "Time", clock() - clk ); -} - - // compute the required times - Map_TimeComputeRequiredGlobal( p ); - // recover switching activity - p->fMappingMode = 4; - Map_MappingMatches( p ); - // compute the references and collect the nodes used in the mapping - Map_MappingSetRefs( p ); - p->AreaFinal = Map_MappingGetArea( p, p->vMapping ); -if ( p->fVerbose ) -{ -printf( "Switching: %s = %8.2f Flow = %11.1f Area = %11.1f %4.1f %% ", - fShowSwitching? "Switch" : "Delay", - fShowSwitching? Map_MappingGetSwitching(p,p->vMapping) : p->fRequiredGlo, - 0.0, p->AreaFinal, - 100.0*(p->AreaBase-p->AreaFinal)/p->AreaBase ); -PRT( "Time", clock() - clk ); -} - } - p->timeArea += clock() - clk; - ////////////////////////////////////////////////////////////////////// - - // print the arrival times of the latest outputs - if ( p->fVerbose ) - Map_MappingPrintOutputArrivals( p ); - return 1; -} diff --git a/src/map/mapper/mapperCreate.c b/src/map/mapper/mapperCreate.c deleted file mode 100644 index 157d467b..00000000 --- a/src/map/mapper/mapperCreate.c +++ /dev/null @@ -1,600 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapperCreate.c] - - PackageName [MVSIS 1.3: Multi-valued logic synthesis system.] - - Synopsis [Generic technology mapping engine.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 2.0. Started - June 1, 2004.] - - Revision [$Id: mapperCreate.c,v 1.15 2005/02/28 05:34:26 alanmi Exp $] - -***********************************************************************/ - -#include "mapperInt.h" - -//////////////////////////////////////////////////////////////////////// -/// DECLARATIONS /// -//////////////////////////////////////////////////////////////////////// - -static void Map_TableCreate( Map_Man_t * p ); -static void Map_TableResize( Map_Man_t * p ); -static Map_Node_t * Map_TableLookup( Map_Man_t * p, Map_Node_t * p1, Map_Node_t * p2 ); - -// hash key for the structural hash table -static inline unsigned Map_HashKey2( Map_Node_t * p0, Map_Node_t * p1, int TableSize ) { return ((unsigned)(p0) + (unsigned)(p1) * 12582917) % TableSize; } - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**Function************************************************************* - - Synopsis [Reads parameters from the mapping manager.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_ManReadInputNum( Map_Man_t * p ) { return p->nInputs; } -int Map_ManReadOutputNum( Map_Man_t * p ) { return p->nOutputs; } -Map_Node_t ** Map_ManReadInputs ( Map_Man_t * p ) { return p->pInputs; } -Map_Node_t ** Map_ManReadOutputs( Map_Man_t * p ) { return p->pOutputs; } -Map_Node_t * Map_ManReadConst1 ( Map_Man_t * p ) { return p->pConst1; } -Map_Time_t * Map_ManReadInputArrivals( Map_Man_t * p ) { return p->pInputArrivals;} -Mio_Library_t * Map_ManReadGenLib ( Map_Man_t * p ) { return p->pSuperLib->pGenlib; } -bool Map_ManReadVerbose( Map_Man_t * p ) { return p->fVerbose; } -float Map_ManReadAreaFinal( Map_Man_t * p ) { return p->AreaFinal; } -float Map_ManReadRequiredGlo( Map_Man_t * p ) { return p->fRequiredGlo; } -void Map_ManSetTimeToMap( Map_Man_t * p, int Time ) { p->timeToMap = Time; } -void Map_ManSetTimeToNet( Map_Man_t * p, int Time ) { p->timeToNet = Time; } -void Map_ManSetTimeSweep( Map_Man_t * p, int Time ) { p->timeSweep = Time; } -void Map_ManSetTimeTotal( Map_Man_t * p, int Time ) { p->timeTotal = Time; } -void Map_ManSetOutputNames( Map_Man_t * p, char ** ppNames ) { p->ppOutputNames = ppNames; } -void Map_ManSetAreaRecovery( Map_Man_t * p, int fAreaRecovery ) { p->fAreaRecovery = fAreaRecovery;} -void Map_ManSetDelayTarget( Map_Man_t * p, float DelayTarget ) { p->DelayTarget = DelayTarget;} -void Map_ManSetInputArrivals( Map_Man_t * p, Map_Time_t * pArrivals ) { p->pInputArrivals = pArrivals;} -void Map_ManSetObeyFanoutLimits( Map_Man_t * p, bool fObeyFanoutLimits ) { p->fObeyFanoutLimits = fObeyFanoutLimits; } -void Map_ManSetNumIterations( Map_Man_t * p, int nIterations ) { p->nIterations = nIterations; } -int Map_ManReadFanoutViolations( Map_Man_t * p ) { return p->nFanoutViolations; } -void Map_ManSetFanoutViolations( Map_Man_t * p, int nVio ) { p->nFanoutViolations = nVio; } -void Map_ManSetChoiceNodeNum( Map_Man_t * p, int nChoiceNodes ) { p->nChoiceNodes = nChoiceNodes; } -void Map_ManSetChoiceNum( Map_Man_t * p, int nChoices ) { p->nChoices = nChoices; } -void Map_ManSetVerbose( Map_Man_t * p, int fVerbose ) { p->fVerbose = fVerbose; } -void Map_ManSetSwitching( Map_Man_t * p, int fSwitching ) { p->fSwitching = fSwitching; } - -/**Function************************************************************* - - Synopsis [Reads parameters from the mapping node.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Man_t * Map_NodeReadMan( Map_Node_t * p ) { return p->p; } -char * Map_NodeReadData( Map_Node_t * p, int fPhase ) { return fPhase? p->pData1 : p->pData0; } -int Map_NodeReadNum( Map_Node_t * p ) { return p->Num; } -int Map_NodeReadLevel( Map_Node_t * p ) { return Map_Regular(p)->Level; } -Map_Cut_t * Map_NodeReadCuts( Map_Node_t * p ) { return p->pCuts; } -Map_Cut_t * Map_NodeReadCutBest( Map_Node_t * p, int fPhase ) { return p->pCutBest[fPhase]; } -Map_Node_t * Map_NodeReadOne( Map_Node_t * p ) { return p->p1; } -Map_Node_t * Map_NodeReadTwo( Map_Node_t * p ) { return p->p2; } -void Map_NodeSetData( Map_Node_t * p, int fPhase, char * pData ) { if (fPhase) p->pData1 = pData; else p->pData0 = pData; } -void Map_NodeSetNextE( Map_Node_t * p, Map_Node_t * pNextE ) { p->pNextE = pNextE; } -void Map_NodeSetRepr( Map_Node_t * p, Map_Node_t * pRepr ) { p->pRepr = pRepr; } -void Map_NodeSetSwitching( Map_Node_t * p, float Switching ) { p->Switching = Switching; } - -/**Function************************************************************* - - Synopsis [Checks the type of the node.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_NodeIsConst( Map_Node_t * p ) { return (Map_Regular(p))->Num == -1; } -int Map_NodeIsVar( Map_Node_t * p ) { return (Map_Regular(p))->p1 == NULL && (Map_Regular(p))->Num >= 0; } -int Map_NodeIsAnd( Map_Node_t * p ) { return (Map_Regular(p))->p1 != NULL; } -int Map_NodeComparePhase( Map_Node_t * p1, Map_Node_t * p2 ) { assert( !Map_IsComplement(p1) ); assert( !Map_IsComplement(p2) ); return p1->fInv ^ p2->fInv; } - -/**Function************************************************************* - - Synopsis [Reads parameters from the cut.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Super_t * Map_CutReadSuperBest( Map_Cut_t * p, int fPhase ) { return p->M[fPhase].pSuperBest;} -Map_Super_t * Map_CutReadSuper0( Map_Cut_t * p ) { return p->M[0].pSuperBest;} -Map_Super_t * Map_CutReadSuper1( Map_Cut_t * p ) { return p->M[1].pSuperBest;} -int Map_CutReadLeavesNum( Map_Cut_t * p ) { return p->nLeaves; } -Map_Node_t ** Map_CutReadLeaves( Map_Cut_t * p ) { return p->ppLeaves; } -unsigned Map_CutReadPhaseBest( Map_Cut_t * p, int fPhase ) { return p->M[fPhase].uPhaseBest;} -unsigned Map_CutReadPhase0( Map_Cut_t * p ) { return p->M[0].uPhaseBest;} -unsigned Map_CutReadPhase1( Map_Cut_t * p ) { return p->M[1].uPhaseBest;} -Map_Cut_t * Map_CutReadNext( Map_Cut_t * p ) { return p->pNext; } - -/**Function************************************************************* - - Synopsis [Reads parameters from the supergate.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -char * Map_SuperReadFormula( Map_Super_t * p ) { return p->pFormula; } -Mio_Gate_t * Map_SuperReadRoot( Map_Super_t * p ) { return p->pRoot; } -int Map_SuperReadNum( Map_Super_t * p ) { return p->Num; } -Map_Super_t ** Map_SuperReadFanins( Map_Super_t * p ) { return p->pFanins; } -int Map_SuperReadFaninNum( Map_Super_t * p ) { return p->nFanins; } -Map_Super_t * Map_SuperReadNext( Map_Super_t * p ) { return p->pNext; } -int Map_SuperReadNumPhases( Map_Super_t * p ) { return p->nPhases; } -unsigned char * Map_SuperReadPhases( Map_Super_t * p ) { return p->uPhases; } -int Map_SuperReadFanoutLimit( Map_Super_t * p ) { return p->nFanLimit;} - -Mio_Library_t * Map_SuperLibReadGenLib( Map_SuperLib_t * p ) { return p->pGenlib; } -float Map_SuperLibReadAreaInv( Map_SuperLib_t * p ) { return p->AreaInv; } -Map_Time_t Map_SuperLibReadDelayInv( Map_SuperLib_t * p ) { return p->tDelayInv;} -int Map_SuperLibReadVarsMax( Map_SuperLib_t * p ) { return p->nVarsMax; } - - -/**Function************************************************************* - - Synopsis [Create the mapping manager.] - - Description [The number of inputs and outputs is assumed to be - known is advance. It is much simpler to have them fixed upfront. - When it comes to representing the object graph in the form of - AIG, the resulting manager is similar to the regular AIG manager, - except that it does not use reference counting (and therefore - does not have garbage collections). It does have table resizing. - The data structure is more flexible to represent additional - information needed for mapping.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Man_t * Map_ManCreate( int nInputs, int nOutputs, int fVerbose ) -{ - Map_Man_t * p; - int i; - - // derive the supergate library - if ( Abc_FrameReadLibSuper() == NULL ) - { - printf( "The supergate library is not specified. Use \"read_library\" or \"read_super\".\n" ); - return NULL; - } - - // start the manager - p = ALLOC( Map_Man_t, 1 ); - memset( p, 0, sizeof(Map_Man_t) ); - p->pSuperLib = Abc_FrameReadLibSuper(); - p->nVarsMax = p->pSuperLib->nVarsMax; - p->fVerbose = fVerbose; - p->fEpsilon = (float)0.001; - assert( p->nVarsMax > 0 ); - - if ( p->nVarsMax == 5 ) - Extra_Truth4VarN( &p->uCanons, &p->uPhases, &p->pCounters, 8 ); - - // start various data structures - Map_TableCreate( p ); - Map_MappingSetupTruthTables( p->uTruths ); - Map_MappingSetupTruthTablesLarge( p->uTruthsLarge ); -// printf( "Node = %d bytes. Cut = %d bytes. Super = %d bytes.\n", sizeof(Map_Node_t), sizeof(Map_Cut_t), sizeof(Map_Super_t) ); - p->mmNodes = Extra_MmFixedStart( sizeof(Map_Node_t) ); - p->mmCuts = Extra_MmFixedStart( sizeof(Map_Cut_t) ); - - // make sure the constant node will get index -1 - p->nNodes = -1; - // create the constant node - p->pConst1 = Map_NodeCreate( p, NULL, NULL ); - p->vNodesAll = Map_NodeVecAlloc( 100 ); - p->vNodesTemp = Map_NodeVecAlloc( 100 ); - p->vMapping = Map_NodeVecAlloc( 100 ); - p->vVisited = Map_NodeVecAlloc( 100 ); - - // create the PI nodes - p->nInputs = nInputs; - p->pInputs = ALLOC( Map_Node_t *, nInputs ); - for ( i = 0; i < nInputs; i++ ) - p->pInputs[i] = Map_NodeCreate( p, NULL, NULL ); - - // create the place for the output nodes - p->nOutputs = nOutputs; - p->pOutputs = ALLOC( Map_Node_t *, nOutputs ); - memset( p->pOutputs, 0, sizeof(Map_Node_t *) * nOutputs ); - return p; -} - -/**Function************************************************************* - - Synopsis [Deallocates the mapping manager.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_ManFree( Map_Man_t * p ) -{ -// int i; -// for ( i = 0; i < p->vNodesAll->nSize; i++ ) -// Map_NodeVecFree( p->vNodesAll->pArray[i]->vFanouts ); -// Map_NodeVecFree( p->pConst1->vFanouts ); - if ( p->vAnds ) - Map_NodeVecFree( p->vAnds ); - if ( p->vNodesAll ) - Map_NodeVecFree( p->vNodesAll ); - if ( p->vNodesTemp ) - Map_NodeVecFree( p->vNodesTemp ); - if ( p->vMapping ) - Map_NodeVecFree( p->vMapping ); - if ( p->vVisited ) - Map_NodeVecFree( p->vVisited ); - if ( p->uCanons ) free( p->uCanons ); - if ( p->uPhases ) free( p->uPhases ); - if ( p->pCounters ) free( p->pCounters ); - Extra_MmFixedStop( p->mmNodes ); - Extra_MmFixedStop( p->mmCuts ); - FREE( p->pInputArrivals ); - FREE( p->pInputs ); - FREE( p->pOutputs ); - FREE( p->pBins ); - FREE( p->ppOutputNames ); - FREE( p ); -} - - -/**Function************************************************************* - - Synopsis [Deallocates the mapping manager.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_ManPrintTimeStats( Map_Man_t * p ) -{ - printf( "N-canonical = %d. Matchings = %d. Phases = %d. ", p->nCanons, p->nMatches, p->nPhases ); - printf( "Choice nodes = %d. Choices = %d.\n", p->nChoiceNodes, p->nChoices ); - PRT( "ToMap", p->timeToMap ); - PRT( "Cuts ", p->timeCuts ); - PRT( "Truth", p->timeTruth ); - PRT( "Match", p->timeMatch ); - PRT( "Area ", p->timeArea ); - PRT( "Sweep", p->timeSweep ); - PRT( "ToNet", p->timeToNet ); - PRT( "TOTAL", p->timeTotal ); - if ( p->time1 ) { PRT( "time1", p->time1 ); } - if ( p->time2 ) { PRT( "time2", p->time2 ); } - if ( p->time3 ) { PRT( "time3", p->time3 ); } -} - -/**Function************************************************************* - - Synopsis [Prints the mapping stats.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_ManPrintStatsToFile( char * pName, float Area, float Delay, int Time ) -{ - FILE * pTable; - pTable = fopen( "map_stats.txt", "a+" ); - fprintf( pTable, "%s ", pName ); - fprintf( pTable, "%4.2f ", Area ); - fprintf( pTable, "%4.2f ", Delay ); - fprintf( pTable, "%4.2f\n", (float)(Time)/(float)(CLOCKS_PER_SEC) ); - fclose( pTable ); -} - -/**Function************************************************************* - - Synopsis [Creates a new node.] - - Description [This procedure should be called to create the constant - node and the PI nodes first.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Node_t * Map_NodeCreate( Map_Man_t * p, Map_Node_t * p1, Map_Node_t * p2 ) -{ - Map_Node_t * pNode; - // create the node - pNode = (Map_Node_t *)Extra_MmFixedEntryFetch( p->mmNodes ); - memset( pNode, 0, sizeof(Map_Node_t) ); - pNode->tRequired[0].Rise = pNode->tRequired[0].Fall = pNode->tRequired[0].Worst = MAP_FLOAT_LARGE; - pNode->tRequired[1].Rise = pNode->tRequired[1].Fall = pNode->tRequired[1].Worst = MAP_FLOAT_LARGE; - pNode->p1 = p1; - pNode->p2 = p2; - pNode->p = p; - // set the number of this node - pNode->Num = p->nNodes++; - // place to store the fanouts -// pNode->vFanouts = Map_NodeVecAlloc( 5 ); - // store this node in the internal array - if ( pNode->Num >= 0 ) - Map_NodeVecPush( p->vNodesAll, pNode ); - else - pNode->fInv = 1; - // set the level of this node - if ( p1 ) - { -#ifdef MAP_ALLOCATE_FANOUT - // create the fanout info - Map_NodeAddFaninFanout( Map_Regular(p1), pNode ); - Map_NodeAddFaninFanout( Map_Regular(p2), pNode ); -#endif - pNode->Level = 1 + MAP_MAX(Map_Regular(pNode->p1)->Level, Map_Regular(pNode->p2)->Level); - pNode->fInv = Map_NodeIsSimComplement(p1) & Map_NodeIsSimComplement(p2); - } - // reference the inputs (will be used to compute the number of fanouts) - if ( p1 ) Map_NodeRef(p1); - if ( p2 ) Map_NodeRef(p2); - - pNode->nRefEst[0] = pNode->nRefEst[1] = -1; - return pNode; -} - -/**Function************************************************************* - - Synopsis [Create the unique table of AND gates.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_TableCreate( Map_Man_t * pMan ) -{ - assert( pMan->pBins == NULL ); - pMan->nBins = Cudd_Prime(5000); - pMan->pBins = ALLOC( Map_Node_t *, pMan->nBins ); - memset( pMan->pBins, 0, sizeof(Map_Node_t *) * pMan->nBins ); - pMan->nNodes = 0; -} - -/**Function************************************************************* - - Synopsis [Looks up the AND2 node in the unique table.] - - Description [This procedure implements one-level hashing. All the nodes - are hashed by their children. If the node with the same children was already - created, it is returned by the call to this procedure. If it does not exist, - this procedure creates a new node with these children. ] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Node_t * Map_TableLookup( Map_Man_t * pMan, Map_Node_t * p1, Map_Node_t * p2 ) -{ - Map_Node_t * pEnt; - unsigned Key; - - if ( p1 == p2 ) - return p1; - if ( p1 == Map_Not(p2) ) - return Map_Not(pMan->pConst1); - if ( Map_NodeIsConst(p1) ) - { - if ( p1 == pMan->pConst1 ) - return p2; - return Map_Not(pMan->pConst1); - } - if ( Map_NodeIsConst(p2) ) - { - if ( p2 == pMan->pConst1 ) - return p1; - return Map_Not(pMan->pConst1); - } - - if ( Map_Regular(p1)->Num > Map_Regular(p2)->Num ) - pEnt = p1, p1 = p2, p2 = pEnt; - - Key = Map_HashKey2( p1, p2, pMan->nBins ); - for ( pEnt = pMan->pBins[Key]; pEnt; pEnt = pEnt->pNext ) - if ( pEnt->p1 == p1 && pEnt->p2 == p2 ) - return pEnt; - // resize the table - if ( pMan->nNodes >= 2 * pMan->nBins ) - { - Map_TableResize( pMan ); - Key = Map_HashKey2( p1, p2, pMan->nBins ); - } - // create the new node - pEnt = Map_NodeCreate( pMan, p1, p2 ); - // add the node to the corresponding linked list in the table - pEnt->pNext = pMan->pBins[Key]; - pMan->pBins[Key] = pEnt; - return pEnt; -} - - -/**Function************************************************************* - - Synopsis [Resizes the table.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_TableResize( Map_Man_t * pMan ) -{ - Map_Node_t ** pBinsNew; - Map_Node_t * pEnt, * pEnt2; - int nBinsNew, Counter, i, clk; - unsigned Key; - -clk = clock(); - // get the new table size - nBinsNew = Cudd_Prime(2 * pMan->nBins); - // allocate a new array - pBinsNew = ALLOC( Map_Node_t *, nBinsNew ); - memset( pBinsNew, 0, sizeof(Map_Node_t *) * nBinsNew ); - // rehash the entries from the old table - Counter = 0; - for ( i = 0; i < pMan->nBins; i++ ) - for ( pEnt = pMan->pBins[i], pEnt2 = pEnt? pEnt->pNext: NULL; pEnt; - pEnt = pEnt2, pEnt2 = pEnt? pEnt->pNext: NULL ) - { - Key = Map_HashKey2( pEnt->p1, pEnt->p2, nBinsNew ); - pEnt->pNext = pBinsNew[Key]; - pBinsNew[Key] = pEnt; - Counter++; - } - assert( Counter == pMan->nNodes - pMan->nInputs ); - if ( pMan->fVerbose ) - { -// printf( "Increasing the unique table size from %6d to %6d. ", pMan->nBins, nBinsNew ); -// PRT( "Time", clock() - clk ); - } - // replace the table and the parameters - free( pMan->pBins ); - pMan->pBins = pBinsNew; - pMan->nBins = nBinsNew; -} - - - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Node_t * Map_NodeAnd( Map_Man_t * p, Map_Node_t * p1, Map_Node_t * p2 ) -{ - Map_Node_t * pNode; - pNode = Map_TableLookup( p, p1, p2 ); - return pNode; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Node_t * Map_NodeOr( Map_Man_t * p, Map_Node_t * p1, Map_Node_t * p2 ) -{ - Map_Node_t * pNode; - pNode = Map_Not( Map_TableLookup( p, Map_Not(p1), Map_Not(p2) ) ); - return pNode; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Node_t * Map_NodeExor( Map_Man_t * p, Map_Node_t * p1, Map_Node_t * p2 ) -{ - return Map_NodeMux( p, p1, Map_Not(p2), p2 ); -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Node_t * Map_NodeMux( Map_Man_t * p, Map_Node_t * pC, Map_Node_t * pT, Map_Node_t * pE ) -{ - Map_Node_t * pAnd1, * pAnd2, * pRes; - pAnd1 = Map_TableLookup( p, pC, pT ); - pAnd2 = Map_TableLookup( p, Map_Not(pC), pE ); - pRes = Map_NodeOr( p, pAnd1, pAnd2 ); - return pRes; -} - - -/**Function************************************************************* - - Synopsis [Sets the node to be equivalent to the given one.] - - Description [This procedure is a work-around for the equivalence check. - Does not verify the equivalence. Use at the user's risk.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_NodeSetChoice( Map_Man_t * pMan, Map_Node_t * pNodeOld, Map_Node_t * pNodeNew ) -{ - pNodeNew->pNextE = pNodeOld->pNextE; - pNodeOld->pNextE = pNodeNew; - pNodeNew->pRepr = pNodeOld; -} - - - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - diff --git a/src/map/mapper/mapperCut.c b/src/map/mapper/mapperCut.c deleted file mode 100644 index b05e9d0c..00000000 --- a/src/map/mapper/mapperCut.c +++ /dev/null @@ -1,1168 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapperCut.c] - - PackageName [MVSIS 1.3: Multi-valued logic synthesis system.] - - Synopsis [Generic technology mapping engine.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 2.0. Started - June 1, 2004.] - - Revision [$Id: mapperCut.c,v 1.12 2005/02/28 05:34:27 alanmi Exp $] - -***********************************************************************/ - -#include "mapperInt.h" - -//////////////////////////////////////////////////////////////////////// -/// DECLARATIONS /// -//////////////////////////////////////////////////////////////////////// - -// the largest number of cuts considered -#define MAP_CUTS_MAX_COMPUTE 1000 -// the largest number of cuts used -#define MAP_CUTS_MAX_USE 250 - -// temporary hash table to store the cuts -typedef struct Map_CutTableStrutct_t Map_CutTable_t; -struct Map_CutTableStrutct_t -{ - Map_Cut_t ** pBins; // the table used for linear probing - int nBins; // the size of the table - int * pCuts; // the array of cuts currently stored - int nCuts; // the number of cuts currently stored - Map_Cut_t ** pArray; // the temporary array of cuts - Map_Cut_t ** pCuts1; // the temporary array of cuts - Map_Cut_t ** pCuts2; // the temporary array of cuts -}; - -// primes used to compute the hash key -static int s_HashPrimes[10] = { 109, 499, 557, 619, 631, 709, 797, 881, 907, 991 }; - -static Map_Cut_t * Map_CutCompute( Map_Man_t * p, Map_CutTable_t * pTable, Map_Node_t * pNode ); -static void Map_CutFilter( Map_Man_t * p, Map_Node_t * pNode ); -static Map_Cut_t * Map_CutMergeLists( Map_Man_t * p, Map_CutTable_t * pTable, Map_Cut_t * pList1, Map_Cut_t * pList2, int fComp1, int fComp2 ); -static int Map_CutMergeTwo( Map_Cut_t * pCut1, Map_Cut_t * pCut2, Map_Node_t * ppNodes[], int nNodesMax ); -static Map_Cut_t * Map_CutUnionLists( Map_Cut_t * pList1, Map_Cut_t * pList2 ); -static int Map_CutBelongsToList( Map_Cut_t * pList, Map_Node_t * ppNodes[], int nNodes ); - -static void Map_CutListPrint( Map_Man_t * pMan, Map_Node_t * pRoot ); -static void Map_CutListPrint2( Map_Man_t * pMan, Map_Node_t * pRoot ); -static void Map_CutPrint_( Map_Man_t * pMan, Map_Cut_t * pCut, Map_Node_t * pRoot ); - -static Map_CutTable_t * Map_CutTableStart( Map_Man_t * pMan ); -static void Map_CutTableStop( Map_CutTable_t * p ); -static unsigned Map_CutTableHash( Map_Node_t * ppNodes[], int nNodes ); -static int Map_CutTableLookup( Map_CutTable_t * p, Map_Node_t * ppNodes[], int nNodes ); -static Map_Cut_t * Map_CutTableConsider( Map_Man_t * pMan, Map_CutTable_t * p, Map_Node_t * ppNodes[], int nNodes ); -static void Map_CutTableRestart( Map_CutTable_t * p ); - -static Map_Cut_t * Map_CutSortCuts( Map_Man_t * pMan, Map_CutTable_t * p, Map_Cut_t * pList ); -static int Map_CutList2Array( Map_Cut_t ** pArray, Map_Cut_t * pList ); -static Map_Cut_t * Map_CutArray2List( Map_Cut_t ** pArray, int nCuts ); - -static unsigned Map_CutComputeTruth( Map_Man_t * p, Map_Cut_t * pCut, Map_Cut_t * pTemp0, Map_Cut_t * pTemp1, int fComp0, int fComp1 ); - -// iterator through all the cuts of the list -#define Map_ListForEachCut( pList, pCut ) \ - for ( pCut = pList; \ - pCut; \ - pCut = pCut->pNext ) -#define Map_ListForEachCutSafe( pList, pCut, pCut2 ) \ - for ( pCut = pList, \ - pCut2 = pCut? pCut->pNext: NULL; \ - pCut; \ - pCut = pCut2, \ - pCut2 = pCut? pCut->pNext: NULL ) - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**Function************************************************************* - - Synopsis [Computes the cuts for each node in the object graph.] - - Description [The cuts are computed in one sweep over the mapping graph. - First, the elementary cuts, which include the node itself, are assigned - to the PI nodes. The internal nodes are considered in the DFS order. - Each node is two-input AND-gate. So to compute the cuts at a node, we - need to merge the sets of cuts of its two predecessors. The merged set - contains only unique cuts with the number of inputs equal to k or less. - Finally, the elementary cut, composed of the node itself, is added to - the set of cuts for the node. - - This procedure is pretty fast for 5-feasible cuts, but it dramatically - slows down on some "dense" networks when computing 6-feasible cuts. - The problem is that there are too many cuts in this case. We should - think how to heuristically trim the number of cuts in such cases, - to have reasonable runtime.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingCuts( Map_Man_t * p ) -{ - ProgressBar * pProgress; - Map_CutTable_t * pTable; - Map_Node_t * pNode; - Map_Cut_t * pCut; - int nCuts, nNodes, i; - int clk = clock(); - // set the elementary cuts for the PI variables - assert( p->nVarsMax > 1 && p->nVarsMax < 7 ); - for ( i = 0; i < p->nInputs; i++ ) - { - pCut = Map_CutAlloc( p ); - pCut->nLeaves = 1; - pCut->ppLeaves[0] = p->pInputs[i]; - p->pInputs[i]->pCuts = pCut; - p->pInputs[i]->pCutBest[0] = NULL; // negative polarity is not mapped - p->pInputs[i]->pCutBest[1] = pCut; // positive polarity is a trivial cut - pCut->uTruth = 0xAAAAAAAA; // the first variable "10101010" - pCut->M[0].AreaFlow = 0.0; - pCut->M[1].AreaFlow = 0.0; - } - - // compute the cuts for the internal nodes - nNodes = p->vAnds->nSize; - pProgress = Extra_ProgressBarStart( stdout, nNodes ); - pTable = Map_CutTableStart( p ); - for ( i = 0; i < nNodes; i++ ) - { - pNode = p->vAnds->pArray[i]; - if ( !Map_NodeIsAnd( pNode ) ) - continue; - Map_CutCompute( p, pTable, pNode ); - Extra_ProgressBarUpdate( pProgress, i, "Cuts ..." ); - } - Extra_ProgressBarStop( pProgress ); - Map_CutTableStop( pTable ); - - // report the stats - if ( p->fVerbose ) - { - nCuts = Map_MappingCountAllCuts(p); - printf( "Nodes = %6d. Total %d-feasible cuts = %10d. Per node = %.1f. ", - p->nNodes, p->nVarsMax, nCuts, ((float)nCuts)/p->nNodes ); - PRT( "Time", clock() - clk ); - } - - // print the cuts for the first primary output -// Map_CutListPrint( p, Map_Regular(p->pOutputs[0]) ); -} - -/**Function************************************************************* - - Synopsis [Computes the cuts for one node.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Cut_t * Map_CutCompute( Map_Man_t * p, Map_CutTable_t * pTable, Map_Node_t * pNode ) -{ - Map_Node_t * pTemp; - Map_Cut_t * pList, * pList1, * pList2; - Map_Cut_t * pCut; - - // if the cuts are computed return them - if ( pNode->pCuts ) - return pNode->pCuts; - - // compute the cuts for the children - pList1 = Map_Regular(pNode->p1)->pCuts; - pList2 = Map_Regular(pNode->p2)->pCuts; - // merge the lists - pList = Map_CutMergeLists( p, pTable, pList1, pList2, - Map_IsComplement(pNode->p1), Map_IsComplement(pNode->p2) ); - // if there are functionally equivalent nodes, union them with this list - assert( pList ); - // only add to the list of cuts if the node is a representative one - if ( pNode->pRepr == NULL ) - { - for ( pTemp = pNode->pNextE; pTemp; pTemp = pTemp->pNextE ) - { - assert( pTemp->pCuts ); - pList = Map_CutUnionLists( pList, pTemp->pCuts ); - assert( pTemp->pCuts ); - pList = Map_CutSortCuts( p, pTable, pList ); - } - } - // add the new cut - pCut = Map_CutAlloc( p ); - pCut->nLeaves = 1; - pCut->ppLeaves[0] = pNode; - pCut->uTruth = 0xAAAAAAAA; - // append (it is important that the elementary cut is appended first) - pCut->pNext = pList; - // set at the node - pNode->pCuts = pCut; - // remove the dominated cuts - Map_CutFilter( p, pNode ); - // set the phase correctly - if ( pNode->pRepr && Map_NodeComparePhase(pNode, pNode->pRepr) ) - { - Map_ListForEachCut( pNode->pCuts, pCut ) - pCut->Phase = 1; - } -/* - { - int i, Counter = 0;; - for ( pCut = pNode->pCuts->pNext; pCut; pCut = pCut->pNext ) - for ( i = 0; i < pCut->nLeaves; i++ ) - Counter += (pCut->ppLeaves[i]->Level >= pNode->Level); -// if ( Counter ) -// printf( " %d", Counter ); - } -*/ - return pCut; -} - -/**Function************************************************************* - - Synopsis [Filter the cuts using dominance.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_CutFilter( Map_Man_t * p, Map_Node_t * pNode ) -{ - Map_Cut_t * pTemp, * pPrev, * pCut, * pCut2; - int i, k, Counter; - - Counter = 0; - pPrev = pNode->pCuts; - Map_ListForEachCutSafe( pNode->pCuts->pNext, pCut, pCut2 ) - { - // go through all the previous cuts up to pCut - for ( pTemp = pNode->pCuts->pNext; pTemp != pCut; pTemp = pTemp->pNext ) - { - // check if every node in pTemp is contained in pCut - for ( i = 0; i < pTemp->nLeaves; i++ ) - { - for ( k = 0; k < pCut->nLeaves; k++ ) - if ( pTemp->ppLeaves[i] == pCut->ppLeaves[k] ) - break; - if ( k == pCut->nLeaves ) // node i in pTemp is not contained in pCut - break; - } - if ( i == pTemp->nLeaves ) // every node in pTemp is contained in pCut - { - Counter++; - break; - } - } - if ( pTemp != pCut ) // pTemp contain pCut - { - pPrev->pNext = pCut->pNext; // skip pCut - // recycle pCut - Map_CutFree( p, pCut ); - } - else - pPrev = pCut; - } -// printf( "Dominated = %3d. \n", Counter ); -} - -/**Function************************************************************* - - Synopsis [Merges two lists of cuts.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Cut_t * Map_CutMergeLists( Map_Man_t * p, Map_CutTable_t * pTable, - Map_Cut_t * pList1, Map_Cut_t * pList2, int fComp1, int fComp2 ) -{ - Map_Node_t * ppNodes[6]; - Map_Cut_t * pListNew, ** ppListNew, * pLists[7] = { NULL }; - Map_Cut_t * pCut, * pPrev, * pTemp1, * pTemp2; - int nNodes, Counter, i; - Map_Cut_t ** ppArray1, ** ppArray2, ** ppArray3; - int nCuts1, nCuts2, nCuts3, k, fComp3; - - ppArray1 = pTable->pCuts1; - ppArray2 = pTable->pCuts2; - nCuts1 = Map_CutList2Array( ppArray1, pList1 ); - nCuts2 = Map_CutList2Array( ppArray2, pList2 ); - // swap the lists based on their length - if ( nCuts1 > nCuts2 ) - { - ppArray3 = ppArray1; - ppArray1 = ppArray2; - ppArray2 = ppArray3; - - nCuts3 = nCuts1; - nCuts1 = nCuts2; - nCuts2 = nCuts3; - - fComp3 = fComp1; - fComp1 = fComp2; - fComp2 = fComp3; - } - // pList1 is shorter or equal length compared to pList2 - - // prepare the manager for the cut computation - Map_CutTableRestart( pTable ); - // go through the cut pairs - Counter = 0; -// for ( pTemp1 = pList1; pTemp1; pTemp1 = fPivot1? NULL: pTemp1->pNext ) -// for ( pTemp2 = pList2; pTemp2; pTemp2 = fPivot2? NULL: pTemp2->pNext ) - for ( i = 0; i < nCuts1; i++ ) - { - for ( k = 0; k <= i; k++ ) - { - pTemp1 = ppArray1[i]; - pTemp2 = ppArray2[k]; - - if ( pTemp1->nLeaves == p->nVarsMax && pTemp2->nLeaves == p->nVarsMax ) - { - if ( pTemp1->ppLeaves[0] != pTemp2->ppLeaves[0] ) - continue; - if ( pTemp1->ppLeaves[1] != pTemp2->ppLeaves[1] ) - continue; - } - - // check if k-feasible cut exists - nNodes = Map_CutMergeTwo( pTemp1, pTemp2, ppNodes, p->nVarsMax ); - if ( nNodes == 0 ) - continue; - // consider the cut for possible addition to the set of new cuts - pCut = Map_CutTableConsider( p, pTable, ppNodes, nNodes ); - if ( pCut == NULL ) - continue; - // add data to the cut - pCut->pOne = Map_CutNotCond( pTemp1, fComp1 ); - pCut->pTwo = Map_CutNotCond( pTemp2, fComp2 ); -// if ( p->nVarsMax == 5 ) -// pCut->uTruth = Map_CutComputeTruth( p, pCut, pTemp1, pTemp2, fComp1, fComp2 ); - // add it to the corresponding list - pCut->pNext = pLists[pCut->nLeaves]; - pLists[pCut->nLeaves] = pCut; - // count this cut and quit if limit is reached - Counter++; - if ( Counter == MAP_CUTS_MAX_COMPUTE ) - goto QUITS; - } - for ( k = 0; k < i; k++ ) - { - pTemp1 = ppArray1[k]; - pTemp2 = ppArray2[i]; - - if ( pTemp1->nLeaves == p->nVarsMax && pTemp2->nLeaves == p->nVarsMax ) - { - if ( pTemp1->ppLeaves[0] != pTemp2->ppLeaves[0] ) - continue; - if ( pTemp1->ppLeaves[1] != pTemp2->ppLeaves[1] ) - continue; - } - - // check if k-feasible cut exists - nNodes = Map_CutMergeTwo( pTemp1, pTemp2, ppNodes, p->nVarsMax ); - if ( nNodes == 0 ) - continue; - // consider the cut for possible addition to the set of new cuts - pCut = Map_CutTableConsider( p, pTable, ppNodes, nNodes ); - if ( pCut == NULL ) - continue; - // add data to the cut - pCut->pOne = Map_CutNotCond( pTemp1, fComp1 ); - pCut->pTwo = Map_CutNotCond( pTemp2, fComp2 ); -// if ( p->nVarsMax == 5 ) -// pCut->uTruth = Map_CutComputeTruth( p, pCut, pTemp1, pTemp2, fComp1, fComp2 ); - // add it to the corresponding list - pCut->pNext = pLists[pCut->nLeaves]; - pLists[pCut->nLeaves] = pCut; - // count this cut and quit if limit is reached - Counter++; - if ( Counter == MAP_CUTS_MAX_COMPUTE ) - goto QUITS; - } - } - // consider the rest of them - for ( i = nCuts1; i < nCuts2; i++ ) - for ( k = 0; k < nCuts1; k++ ) - { - pTemp1 = ppArray1[k]; - pTemp2 = ppArray2[i]; - - if ( pTemp1->nLeaves == p->nVarsMax && pTemp2->nLeaves == p->nVarsMax ) - { - if ( pTemp1->ppLeaves[0] != pTemp2->ppLeaves[0] ) - continue; - if ( pTemp1->ppLeaves[1] != pTemp2->ppLeaves[1] ) - continue; - } - - // check if k-feasible cut exists - nNodes = Map_CutMergeTwo( pTemp1, pTemp2, ppNodes, p->nVarsMax ); - if ( nNodes == 0 ) - continue; - // consider the cut for possible addition to the set of new cuts - pCut = Map_CutTableConsider( p, pTable, ppNodes, nNodes ); - if ( pCut == NULL ) - continue; - // add data to the cut - pCut->pOne = Map_CutNotCond( pTemp1, fComp1 ); - pCut->pTwo = Map_CutNotCond( pTemp2, fComp2 ); -// if ( p->nVarsMax == 5 ) -// pCut->uTruth = Map_CutComputeTruth( p, pCut, pTemp1, pTemp2, fComp1, fComp2 ); - // add it to the corresponding list - pCut->pNext = pLists[pCut->nLeaves]; - pLists[pCut->nLeaves] = pCut; - // count this cut and quit if limit is reached - Counter++; - if ( Counter == MAP_CUTS_MAX_COMPUTE ) - goto QUITS; - } -QUITS : - // combine all the lists into one - pListNew = NULL; - ppListNew = &pListNew; - for ( i = 1; i <= p->nVarsMax; i++ ) - { - if ( pLists[i] == NULL ) - continue; - // find the last entry - for ( pPrev = pLists[i], pCut = pPrev->pNext; pCut; - pPrev = pCut, pCut = pCut->pNext ); - // connect these lists - *ppListNew = pLists[i]; - ppListNew = &pPrev->pNext; - } - *ppListNew = NULL; - // soft the cuts by arrival times and use only the first MAP_CUTS_MAX_USE - pListNew = Map_CutSortCuts( p, pTable, pListNew ); - return pListNew; -} - - -/**Function************************************************************* - - Synopsis [Merges two lists of cuts.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Cut_t * Map_CutMergeLists2( Map_Man_t * p, Map_CutTable_t * pTable, - Map_Cut_t * pList1, Map_Cut_t * pList2, int fComp1, int fComp2 ) -{ - Map_Node_t * ppNodes[6]; - Map_Cut_t * pListNew, ** ppListNew, * pLists[7] = { NULL }; - Map_Cut_t * pCut, * pPrev, * pTemp1, * pTemp2; - int nNodes, Counter, i; - - // prepare the manager for the cut computation - Map_CutTableRestart( pTable ); - // go through the cut pairs - Counter = 0; - for ( pTemp1 = pList1; pTemp1; pTemp1 = pTemp1->pNext ) - for ( pTemp2 = pList2; pTemp2; pTemp2 = pTemp2->pNext ) - { - // check if k-feasible cut exists - nNodes = Map_CutMergeTwo( pTemp1, pTemp2, ppNodes, p->nVarsMax ); - if ( nNodes == 0 ) - continue; - // consider the cut for possible addition to the set of new cuts - pCut = Map_CutTableConsider( p, pTable, ppNodes, nNodes ); - if ( pCut == NULL ) - continue; - // add data to the cut - pCut->pOne = Map_CutNotCond( pTemp1, fComp1 ); - pCut->pTwo = Map_CutNotCond( pTemp2, fComp2 ); - // add it to the corresponding list - pCut->pNext = pLists[pCut->nLeaves]; - pLists[pCut->nLeaves] = pCut; - // count this cut and quit if limit is reached - Counter++; - if ( Counter == MAP_CUTS_MAX_COMPUTE ) - goto QUITS; - } -QUITS : - // combine all the lists into one - pListNew = NULL; - ppListNew = &pListNew; - for ( i = 1; i <= p->nVarsMax; i++ ) - { - if ( pLists[i] == NULL ) - continue; - // find the last entry - for ( pPrev = pLists[i], pCut = pPrev->pNext; pCut; - pPrev = pCut, pCut = pCut->pNext ); - // connect these lists - *ppListNew = pLists[i]; - ppListNew = &pPrev->pNext; - } - *ppListNew = NULL; - // soft the cuts by arrival times and use only the first MAP_CUTS_MAX_USE - pListNew = Map_CutSortCuts( p, pTable, pListNew ); - return pListNew; -} - -/**Function************************************************************* - - Synopsis [Merges two cuts.] - - Description [Returns the number of nodes in the resulting cut, or 0 if the - cut is infeasible. Returns the resulting nodes in the array ppNodes[].] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_CutMergeTwo( Map_Cut_t * pCut1, Map_Cut_t * pCut2, Map_Node_t * ppNodes[], int nNodesMax ) -{ - Map_Node_t * pNodeTemp; - int nTotal, i, k, min, fMismatch; - - // check the special case when at least of the cuts is the largest - if ( pCut1->nLeaves == nNodesMax ) - { - if ( pCut2->nLeaves == nNodesMax ) - { - // return 0 if the cuts are different - for ( i = 0; i < nNodesMax; i++ ) - if ( pCut1->ppLeaves[i] != pCut2->ppLeaves[i] ) - return 0; - // return nNodesMax if they are the same - for ( i = 0; i < nNodesMax; i++ ) - ppNodes[i] = pCut1->ppLeaves[i]; - return nNodesMax; - } - else if ( pCut2->nLeaves == nNodesMax - 1 ) - { - // return 0 if the cuts are different - fMismatch = 0; - for ( i = 0; i < nNodesMax; i++ ) - if ( pCut1->ppLeaves[i] != pCut2->ppLeaves[i - fMismatch] ) - { - if ( fMismatch == 1 ) - return 0; - fMismatch = 1; - } - // return nNodesMax if they are the same - for ( i = 0; i < nNodesMax; i++ ) - ppNodes[i] = pCut1->ppLeaves[i]; - return nNodesMax; - } - } - else if ( pCut1->nLeaves == nNodesMax - 1 && pCut2->nLeaves == nNodesMax ) - { - // return 0 if the cuts are different - fMismatch = 0; - for ( i = 0; i < nNodesMax; i++ ) - if ( pCut1->ppLeaves[i - fMismatch] != pCut2->ppLeaves[i] ) - { - if ( fMismatch == 1 ) - return 0; - fMismatch = 1; - } - // return nNodesMax if they are the same - for ( i = 0; i < nNodesMax; i++ ) - ppNodes[i] = pCut2->ppLeaves[i]; - return nNodesMax; - } - - // count the number of unique entries in pCut2 - nTotal = pCut1->nLeaves; - for ( i = 0; i < pCut2->nLeaves; i++ ) - { - // try to find this entry among the leaves of pCut1 - for ( k = 0; k < pCut1->nLeaves; k++ ) - if ( pCut2->ppLeaves[i] == pCut1->ppLeaves[k] ) - break; - if ( k < pCut1->nLeaves ) // found - continue; - // we found a new entry to add - if ( nTotal == nNodesMax ) - return 0; - ppNodes[nTotal++] = pCut2->ppLeaves[i]; - } - // we know that the feasible cut exists - - // add the starting entries - for ( k = 0; k < pCut1->nLeaves; k++ ) - ppNodes[k] = pCut1->ppLeaves[k]; - - // selection-sort the entries - for ( i = 0; i < nTotal - 1; i++ ) - { - min = i; - for ( k = i+1; k < nTotal; k++ ) -// if ( ppNodes[k] < ppNodes[min] ) // reported bug fix (non-determinism!) - if ( ppNodes[k]->Num < ppNodes[min]->Num ) - min = k; - pNodeTemp = ppNodes[i]; - ppNodes[i] = ppNodes[min]; - ppNodes[min] = pNodeTemp; - } - - return nTotal; -} - -/**Function************************************************************* - - Synopsis [Computes the union of the two lists of cuts.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Cut_t * Map_CutUnionLists( Map_Cut_t * pList1, Map_Cut_t * pList2 ) -{ - Map_Cut_t * pTemp, * pRoot; - // find the last cut in the first list - pRoot = pList1; - Map_ListForEachCut( pList1, pTemp ) - pRoot = pTemp; - // attach the non-trival part of the second cut to the end of the first - assert( pRoot->pNext == NULL ); - pRoot->pNext = pList2->pNext; - pList2->pNext = NULL; - return pList1; -} - - -/**Function************************************************************* - - Synopsis [Checks whether the given cut belongs to the list.] - - Description [This procedure takes most of the runtime in the cut - computation.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_CutBelongsToList( Map_Cut_t * pList, Map_Node_t * ppNodes[], int nNodes ) -{ - Map_Cut_t * pTemp; - int i; - for ( pTemp = pList; pTemp; pTemp = pTemp->pNext ) - { - for ( i = 0; i < nNodes; i++ ) - if ( pTemp->ppLeaves[i] != ppNodes[i] ) - break; - if ( i == nNodes ) - return 1; - } - return 0; -} - -/**Function************************************************************* - - Synopsis [Counts all the cuts.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_MappingCountAllCuts( Map_Man_t * pMan ) -{ - Map_Node_t * pNode; - Map_Cut_t * pCut; - int i, nCuts; -// int nCuts55 = 0, nCuts5x = 0, nCuts4x = 0, nCuts3x = 0; -// int pCounts[7] = {0}; - nCuts = 0; - for ( i = 0; i < pMan->nBins; i++ ) - for ( pNode = pMan->pBins[i]; pNode; pNode = pNode->pNext ) - for ( pCut = pNode->pCuts; pCut; pCut = pCut->pNext ) - if ( pCut->nLeaves > 1 ) // skip the elementary cuts - { - nCuts++; -/* - if ( Map_CutRegular(pCut->pOne)->nLeaves == 5 && Map_CutRegular(pCut->pTwo)->nLeaves == 5 ) - nCuts55++; - if ( Map_CutRegular(pCut->pOne)->nLeaves == 5 || Map_CutRegular(pCut->pTwo)->nLeaves == 5 ) - nCuts5x++; - else if ( Map_CutRegular(pCut->pOne)->nLeaves == 4 || Map_CutRegular(pCut->pTwo)->nLeaves == 4 ) - nCuts4x++; - else if ( Map_CutRegular(pCut->pOne)->nLeaves == 3 || Map_CutRegular(pCut->pTwo)->nLeaves == 3 ) - nCuts3x++; -*/ -// pCounts[ Map_CutRegular(pCut->pOne)->nLeaves ]++; -// pCounts[ Map_CutRegular(pCut->pTwo)->nLeaves ]++; - } -// printf( "Total cuts = %6d. 55 = %6d. 5x = %6d. 4x = %6d. 3x = %6d.\n", nCuts, nCuts55, nCuts5x, nCuts4x, nCuts3x ); - -// printf( "Total cuts = %6d. 6= %6d. 5= %6d. 4= %6d. 3= %6d. 2= %6d. 1= %6d.\n", -// nCuts, pCounts[6], pCounts[5], pCounts[4], pCounts[3], pCounts[2], pCounts[1] ); - return nCuts; -} - - -/**Function************************************************************* - - Synopsis [Prints the cuts in the list.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_CutListPrint( Map_Man_t * pMan, Map_Node_t * pRoot ) -{ - Map_Cut_t * pTemp; - int Counter; - for ( Counter = 0, pTemp = pRoot->pCuts; pTemp; pTemp = pTemp->pNext, Counter++ ) - { - printf( "%2d : ", Counter + 1 ); - Map_CutPrint_( pMan, pTemp, pRoot ); - } -} - -/**Function************************************************************* - - Synopsis [Prints the cuts in the list.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_CutListPrint2( Map_Man_t * pMan, Map_Node_t * pRoot ) -{ - Map_Cut_t * pTemp; - int Counter; - for ( Counter = 0, pTemp = pRoot->pCuts; pTemp; pTemp = pTemp->pNext, Counter++ ) - { - printf( "%2d : ", Counter + 1 ); - Map_CutPrint_( pMan, pTemp, pRoot ); - } -} - -/**Function************************************************************* - - Synopsis [Prints the cut.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_CutPrint_( Map_Man_t * pMan, Map_Cut_t * pCut, Map_Node_t * pRoot ) -{ - int i; - printf( "(%3d) {", pRoot->Num ); - for ( i = 0; i < pMan->nVarsMax; i++ ) - if ( pCut->ppLeaves[i] ) - printf( " %3d", pCut->ppLeaves[i]->Num ); - printf( " }\n" ); -} - - - - - - - - -/**Function************************************************************* - - Synopsis [Starts the hash table to canonicize cuts.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_CutTable_t * Map_CutTableStart( Map_Man_t * pMan ) -{ - Map_CutTable_t * p; - // allocate the table - p = ALLOC( Map_CutTable_t, 1 ); - memset( p, 0, sizeof(Map_CutTable_t) ); - p->nBins = Cudd_Prime( 10 * MAP_CUTS_MAX_COMPUTE ); - p->pBins = ALLOC( Map_Cut_t *, p->nBins ); - memset( p->pBins, 0, sizeof(Map_Cut_t *) * p->nBins ); - p->pCuts = ALLOC( int, 2 * MAP_CUTS_MAX_COMPUTE ); - p->pArray = ALLOC( Map_Cut_t *, 2 * MAP_CUTS_MAX_COMPUTE ); - p->pCuts1 = ALLOC( Map_Cut_t *, 2 * MAP_CUTS_MAX_COMPUTE ); - p->pCuts2 = ALLOC( Map_Cut_t *, 2 * MAP_CUTS_MAX_COMPUTE ); - return p; -} - -/**Function************************************************************* - - Synopsis [Stops the hash table.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_CutTableStop( Map_CutTable_t * p ) -{ - free( p->pCuts1 ); - free( p->pCuts2 ); - free( p->pArray ); - free( p->pBins ); - free( p->pCuts ); - free( p ); -} - -/**Function************************************************************* - - Synopsis [Computes the hash value of the cut.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -unsigned Map_CutTableHash( Map_Node_t * ppNodes[], int nNodes ) -{ - unsigned uRes; - int i; - uRes = 0; - for ( i = 0; i < nNodes; i++ ) - uRes += s_HashPrimes[i] * ppNodes[i]->Num; - return uRes; -} - -/**Function************************************************************* - - Synopsis [Looks up the table for the available cut.] - - Description [Returns -1 if the same cut is found. Returns the index - of the cell where the cut should be added, if it does not exist.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_CutTableLookup( Map_CutTable_t * p, Map_Node_t * ppNodes[], int nNodes ) -{ - Map_Cut_t * pCut; - unsigned Key; - int b, i; - - Key = Map_CutTableHash(ppNodes, nNodes) % p->nBins; - for ( b = Key; p->pBins[b]; b = (b+1) % p->nBins ) - { - pCut = p->pBins[b]; - if ( pCut->nLeaves != nNodes ) - continue; - for ( i = 0; i < nNodes; i++ ) - if ( pCut->ppLeaves[i] != ppNodes[i] ) - break; - if ( i == nNodes ) - return -1; - } - return b; -} - - -/**Function************************************************************* - - Synopsis [Starts the hash table to canonicize cuts.] - - Description [Considers addition of the cut to the hash table.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Cut_t * Map_CutTableConsider( Map_Man_t * pMan, Map_CutTable_t * p, Map_Node_t * ppNodes[], int nNodes ) -{ - Map_Cut_t * pCut; - int Place, i; -// int clk; - // check the cut - Place = Map_CutTableLookup( p, ppNodes, nNodes ); - if ( Place == -1 ) - return NULL; - assert( nNodes > 0 ); - // create the new cut -//clk = clock(); - pCut = Map_CutAlloc( pMan ); -//pMan->time1 += clock() - clk; - pCut->nLeaves = nNodes; - for ( i = 0; i < nNodes; i++ ) - pCut->ppLeaves[i] = ppNodes[i]; - // add the cut to the table - assert( p->pBins[Place] == NULL ); - p->pBins[Place] = pCut; - // add the cut to the new list - p->pCuts[ p->nCuts++ ] = Place; - return pCut; -} - -/**Function************************************************************* - - Synopsis [Prepares the table to be used with other cuts.] - - Description [Restarts the table by cleaning the info about cuts stored - when the previous node was considered.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_CutTableRestart( Map_CutTable_t * p ) -{ - int i; - for ( i = 0; i < p->nCuts; i++ ) - { - assert( p->pBins[ p->pCuts[i] ] ); - p->pBins[ p->pCuts[i] ] = NULL; - } - p->nCuts = 0; -} - - - -/**Function************************************************************* - - Synopsis [Compares the cuts by the number of leaves and then by delay.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_CutSortCutsCompare( Map_Cut_t ** pC1, Map_Cut_t ** pC2 ) -{ - if ( (*pC1)->nLeaves < (*pC2)->nLeaves ) - return -1; - if ( (*pC1)->nLeaves > (*pC2)->nLeaves ) - return 1; - return 0; -} - -/**Function************************************************************* - - Synopsis [Sorts the cuts by average arrival time.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Cut_t * Map_CutSortCuts( Map_Man_t * pMan, Map_CutTable_t * p, Map_Cut_t * pList ) -{ - Map_Cut_t * pListNew; - int nCuts, i; -// int clk; - // move the cuts from the list into the array - nCuts = Map_CutList2Array( p->pCuts1, pList ); - assert( nCuts <= MAP_CUTS_MAX_COMPUTE ); - // sort the cuts -//clk = clock(); - qsort( (void *)p->pCuts1, nCuts, sizeof(Map_Cut_t *), - (int (*)(const void *, const void *)) Map_CutSortCutsCompare ); -//pMan->time2 += clock() - clk; - // move them back into the list - if ( nCuts > MAP_CUTS_MAX_USE - 1 ) - { - // free the remaining cuts - for ( i = MAP_CUTS_MAX_USE - 1; i < nCuts; i++ ) - Extra_MmFixedEntryRecycle( pMan->mmCuts, (char *)p->pCuts1[i] ); - // update the number of cuts - nCuts = MAP_CUTS_MAX_USE - 1; - } - pListNew = Map_CutArray2List( p->pCuts1, nCuts ); - return pListNew; -} - -/**Function************************************************************* - - Synopsis [Moves the nodes from the list into the array.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_CutList2Array( Map_Cut_t ** pArray, Map_Cut_t * pList ) -{ - int i; - for ( i = 0; pList; pList = pList->pNext, i++ ) - pArray[i] = pList; - return i; -} - -/**Function************************************************************* - - Synopsis [Moves the nodes from the array into the list.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Cut_t * Map_CutArray2List( Map_Cut_t ** pArray, int nCuts ) -{ - Map_Cut_t * pListNew, ** ppListNew; - int i; - pListNew = NULL; - ppListNew = &pListNew; - for ( i = 0; i < nCuts; i++ ) - { - // connect these lists - *ppListNew = pArray[i]; - ppListNew = &pArray[i]->pNext; - } -//printf( "\n" ); - - *ppListNew = NULL; - return pListNew; -} - - -/**Function************************************************************* - - Synopsis [Computes the truth table of the 5-input cut.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -unsigned Map_CutComputeTruth( Map_Man_t * p, Map_Cut_t * pCut, Map_Cut_t * pTemp0, Map_Cut_t * pTemp1, int fComp0, int fComp1 ) -{ - static unsigned ** pPerms53 = NULL; - static unsigned ** pPerms54 = NULL; - - unsigned uPhase, uTruth, uTruth0, uTruth1; - int i, k; - - if ( pPerms53 == NULL ) - { - pPerms53 = (unsigned **)Extra_TruthPerm53(); - pPerms54 = (unsigned **)Extra_TruthPerm54(); - } - - // find the mapping from the old nodes to the new - if ( pTemp0->nLeaves == pCut->nLeaves ) - uTruth0 = pTemp0->uTruth; - else - { - assert( pTemp0->nLeaves < pCut->nLeaves ); - uPhase = 0; - for ( i = 0; i < (int)pTemp0->nLeaves; i++ ) - { - for ( k = 0; k < pCut->nLeaves; k++ ) - if ( pTemp0->ppLeaves[i] == pCut->ppLeaves[k] ) - break; - uPhase |= (1 << k); - } - assert( uPhase < 32 ); - if ( pTemp0->nLeaves == 4 ) - { - if ( uPhase == 31-16 ) // 01111 - uTruth0 = pTemp0->uTruth; - else if ( uPhase == 31-8 ) // 10111 - uTruth0 = pPerms54[pTemp0->uTruth & 0xFFFF][0]; - else if ( uPhase == 31-4 ) // 11011 - uTruth0 = pPerms54[pTemp0->uTruth & 0xFFFF][1]; - else if ( uPhase == 31-2 ) // 11101 - uTruth0 = pPerms54[pTemp0->uTruth & 0xFFFF][2]; - else if ( uPhase == 31-1 ) // 11110 - uTruth0 = pPerms54[pTemp0->uTruth & 0xFFFF][3]; - else - assert( 0 ); - } - else - uTruth0 = pPerms53[pTemp0->uTruth & 0xFF][uPhase]; - } - uTruth0 = fComp0? ~uTruth0: uTruth0; - - // find the mapping from the old nodes to the new - if ( pTemp1->nLeaves == pCut->nLeaves ) - uTruth1 = pTemp1->uTruth; - else - { - assert( pTemp1->nLeaves < pCut->nLeaves ); - uPhase = 0; - for ( i = 0; i < (int)pTemp1->nLeaves; i++ ) - { - for ( k = 0; k < pCut->nLeaves; k++ ) - if ( pTemp1->ppLeaves[i] == pCut->ppLeaves[k] ) - break; - uPhase |= (1 << k); - } - assert( uPhase < 32 ); - if ( pTemp1->nLeaves == 4 ) - { - if ( uPhase == 31-16 ) // 01111 - uTruth1 = pTemp1->uTruth; - else if ( uPhase == 31-8 ) // 10111 - uTruth1 = pPerms54[pTemp1->uTruth & 0xFFFF][0]; - else if ( uPhase == 31-4 ) // 11011 - uTruth1 = pPerms54[pTemp1->uTruth & 0xFFFF][1]; - else if ( uPhase == 31-2 ) // 11101 - uTruth1 = pPerms54[pTemp1->uTruth & 0xFFFF][2]; - else if ( uPhase == 31-1 ) // 11110 - uTruth1 = pPerms54[pTemp1->uTruth & 0xFFFF][3]; - else - assert( 0 ); - } - else - uTruth1 = pPerms53[pTemp1->uTruth & 0xFF][uPhase]; - } - uTruth1 = fComp1? ~uTruth1: uTruth1; - uTruth = uTruth0 & uTruth1; - return uTruth; -} - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - diff --git a/src/map/mapper/mapperCutUtils.c b/src/map/mapper/mapperCutUtils.c deleted file mode 100644 index 4450cb04..00000000 --- a/src/map/mapper/mapperCutUtils.c +++ /dev/null @@ -1,273 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapperCutUtils.c] - - PackageName [MVSIS 1.3: Multi-valued logic synthesis system.] - - Synopsis [Generic technology mapping engine.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 2.0. Started - June 1, 2004.] - - Revision [$Id: mapperCutUtils.h,v 1.0 2003/09/08 00:00:00 alanmi Exp $] - -***********************************************************************/ - -#include "mapperInt.h" - -//////////////////////////////////////////////////////////////////////// -/// DECLARATIONS /// -//////////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**Function************************************************************* - - Synopsis [Allocates the cut.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Cut_t * Map_CutAlloc( Map_Man_t * p ) -{ - Map_Cut_t * pCut; - Map_Match_t * pMatch; - pCut = (Map_Cut_t *)Extra_MmFixedEntryFetch( p->mmCuts ); - memset( pCut, 0, sizeof(Map_Cut_t) ); - - pMatch = pCut->M; - pMatch->AreaFlow = MAP_FLOAT_LARGE; // unassigned - pMatch->tArrive.Rise = MAP_FLOAT_LARGE; // unassigned - pMatch->tArrive.Fall = MAP_FLOAT_LARGE; // unassigned - pMatch->tArrive.Worst = MAP_FLOAT_LARGE; // unassigned - - pMatch = pCut->M + 1; - pMatch->AreaFlow = MAP_FLOAT_LARGE; // unassigned - pMatch->tArrive.Rise = MAP_FLOAT_LARGE; // unassigned - pMatch->tArrive.Fall = MAP_FLOAT_LARGE; // unassigned - pMatch->tArrive.Worst = MAP_FLOAT_LARGE; // unassigned - return pCut; -} - -/**Function************************************************************* - - Synopsis [Deallocates the cut.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_CutFree( Map_Man_t * p, Map_Cut_t * pCut ) -{ - if ( pCut ) - Extra_MmFixedEntryRecycle( p->mmCuts, (char *)pCut ); -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_CutPrint( Map_Man_t * p, Map_Node_t * pRoot, Map_Cut_t * pCut, int fPhase ) -{ - int i; - printf( "CUT: Delay = (%4.2f, %4.2f). Area = %4.2f. Nodes = %d -> {", - pCut->M[fPhase].tArrive.Rise, pCut->M[fPhase].tArrive.Fall, pCut->M[fPhase].AreaFlow, pRoot->Num ); - for ( i = 0; i < pCut->nLeaves; i++ ) - printf( " %d", pCut->ppLeaves[i]->Num ); - printf( " } \n" ); -} - - -/**function************************************************************* - - synopsis [Computes the exact area associated with the cut.] - - description [] - - sideeffects [] - - seealso [] - -***********************************************************************/ -float Map_CutGetRootArea( Map_Cut_t * pCut, int fPhase ) -{ - assert( pCut->M[fPhase].pSuperBest ); - return pCut->M[fPhase].pSuperBest->Area; -} - -/**function************************************************************* - - synopsis [Computes the exact area associated with the cut.] - - description [] - - sideeffects [] - - seealso [] - -***********************************************************************/ -int Map_CutGetLeafPhase( Map_Cut_t * pCut, int fPhase, int iLeaf ) -{ - assert( pCut->M[fPhase].pSuperBest ); - return (( pCut->M[fPhase].uPhaseBest & (1<pCutBest[fPhase]->M[fPhase].pSuperBest ); - return (( pNode->pCutBest[fPhase]->M[fPhase].uPhaseBest & (1<pNext ) - pPrev = pTemp; - // append all the end of the current set - assert( pPrev->pNext == NULL ); - pPrev->pNext = pSetAll; - return pSets; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_CutListRecycle( Map_Man_t * p, Map_Cut_t * pSetList, Map_Cut_t * pSave ) -{ - Map_Cut_t * pNext, * pTemp; - for ( pTemp = pSetList, pNext = pTemp? pTemp->pNext : NULL; - pTemp; - pTemp = pNext, pNext = pNext? pNext->pNext : NULL ) - if ( pTemp != pSave ) - Extra_MmFixedEntryRecycle( p->mmCuts, (char *)pTemp ); -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_CutListCount( Map_Cut_t * pSets ) -{ - Map_Cut_t * pTemp; - int i; - for ( i = 0, pTemp = pSets; pTemp; pTemp = pTemp->pNext, i++ ); - return i; -} - -#if 0 - -/**function************************************************************* - - synopsis [Removes the fanouts of the cut.] - - description [] - - sideeffects [] - - seealso [] - -***********************************************************************/ -void Map_CutRemoveFanouts( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase ) -{ - Map_NodeVec_t * vFanouts; - int i, k; - for ( i = 0; i < pCut->nLeaves; i++ ) - { - vFanouts = pCut->ppLeaves[i]->vFanouts; - for ( k = 0; k < vFanouts->nSize; k++ ) - if ( vFanouts->pArray[k] == pNode ) - break; - assert( k != vFanouts->nSize ); - for ( k++; k < vFanouts->nSize; k++ ) - vFanouts->pArray[k-1] = vFanouts->pArray[k]; - vFanouts->nSize--; - } -} - -/**function************************************************************* - - synopsis [Removes the fanouts of the cut.] - - description [] - - sideeffects [] - - seealso [] - -***********************************************************************/ -void Map_CutInsertFanouts( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase ) -{ - int i; - for ( i = 0; i < pCut->nLeaves; i++ ) - Map_NodeVecPush( pCut->ppLeaves[i]->vFanouts, pNode ); -} - -#endif - - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - - diff --git a/src/map/mapper/mapperFanout.c b/src/map/mapper/mapperFanout.c deleted file mode 100644 index 63cdbd2a..00000000 --- a/src/map/mapper/mapperFanout.c +++ /dev/null @@ -1,141 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapperFanout.c] - - PackageName [FRAIG: Functionally reduced AND-INV graphs.] - - Synopsis [Procedures to manipulate fanouts of the FRAIG nodes.] - - Author [Alan Mishchenko ] - - Affiliation [UC Berkeley] - - Date [Ver. 2.0. Started - June 1, 2004.] - - Revision [$Id: mapperFanout.c,v 1.5 2005/01/23 06:59:43 alanmi Exp $] - -***********************************************************************/ - -#include "mapperInt.h" - -#ifdef MAP_ALLOCATE_FANOUT - -//////////////////////////////////////////////////////////////////////// -/// DECLARATIONS /// -//////////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**Function************************************************************* - - Synopsis [Add the fanout to the node.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_NodeAddFaninFanout( Map_Node_t * pFanin, Map_Node_t * pFanout ) -{ - Map_Node_t * pPivot; - - // pFanins is a fanin of pFanout - assert( !Map_IsComplement(pFanin) ); - assert( !Map_IsComplement(pFanout) ); - assert( Map_Regular(pFanout->p1) == pFanin || Map_Regular(pFanout->p2) == pFanin ); - - pPivot = pFanin->pFanPivot; - if ( pPivot == NULL ) - { - pFanin->pFanPivot = pFanout; - return; - } - - if ( Map_Regular(pPivot->p1) == pFanin ) - { - if ( Map_Regular(pFanout->p1) == pFanin ) - { - pFanout->pFanFanin1 = pPivot->pFanFanin1; - pPivot->pFanFanin1 = pFanout; - } - else // if ( Map_Regular(pFanout->p2) == pFanin ) - { - pFanout->pFanFanin2 = pPivot->pFanFanin1; - pPivot->pFanFanin1 = pFanout; - } - } - else // if ( Map_Regular(pPivot->p2) == pFanin ) - { - assert( Map_Regular(pPivot->p2) == pFanin ); - if ( Map_Regular(pFanout->p1) == pFanin ) - { - pFanout->pFanFanin1 = pPivot->pFanFanin2; - pPivot->pFanFanin2 = pFanout; - } - else // if ( Map_Regular(pFanout->p2) == pFanin ) - { - pFanout->pFanFanin2 = pPivot->pFanFanin2; - pPivot->pFanFanin2 = pFanout; - } - } -} - -/**Function************************************************************* - - Synopsis [Add the fanout to the node.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_NodeRemoveFaninFanout( Map_Node_t * pFanin, Map_Node_t * pFanoutToRemove ) -{ - Map_Node_t * pFanout, * pFanout2, ** ppFanList; - // start the linked list of fanouts - ppFanList = &pFanin->pFanPivot; - // go through the fanouts - Map_NodeForEachFanoutSafe( pFanin, pFanout, pFanout2 ) - { - // skip the fanout-to-remove - if ( pFanout == pFanoutToRemove ) - continue; - // add useful fanouts to the list - *ppFanList = pFanout; - ppFanList = Map_NodeReadNextFanoutPlace( pFanin, pFanout ); - } - *ppFanList = NULL; -} - -/**Function************************************************************* - - Synopsis [Returns the number of fanouts of a node.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_NodeGetFanoutNum( Map_Node_t * pNode ) -{ - Map_Node_t * pFanout; - int Counter = 0; - Map_NodeForEachFanout( pNode, pFanout ) - Counter++; - return Counter; -} - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - -#endif - diff --git a/src/map/mapper/mapperGENERIC.c b/src/map/mapper/mapperGENERIC.c deleted file mode 100644 index 823eb4f2..00000000 --- a/src/map/mapper/mapperGENERIC.c +++ /dev/null @@ -1,46 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapper__.c] - - PackageName [MVSIS 1.3: Multi-valued logic synthesis system.] - - Synopsis [Generic technology mapping engine.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 1.0. Started - September 8, 2003.] - - Revision [$Id: mapper__.h,v 1.0 2003/09/08 00:00:00 alanmi Exp $] - -***********************************************************************/ - -#include "mapperInt.h" - -//////////////////////////////////////////////////////////////////////// -/// DECLARATIONS /// -//////////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ - - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - - diff --git a/src/map/mapper/mapperInt.h b/src/map/mapper/mapperInt.h deleted file mode 100644 index 37cca3d3..00000000 --- a/src/map/mapper/mapperInt.h +++ /dev/null @@ -1,477 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapperInt.h] - - PackageName [MVSIS 2.0: Multi-valued logic synthesis system.] - - Synopsis [Generic technology mapping engine.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 2.0. Started - June 1, 2004.] - - Revision [$Id: mapperInt.h,v 1.8 2004/09/30 21:18:10 satrajit Exp $] - -***********************************************************************/ - -#ifndef __MAPPER_INT_H__ -#define __MAPPER_INT_H__ - -//////////////////////////////////////////////////////////////////////// -/// INCLUDES /// -//////////////////////////////////////////////////////////////////////// - -//#include "leaks.h" -#include -#include -#include -#include -#include "cuddInt.h" -#include "main.h" -#include "mio.h" -#include "mapper.h" - -//////////////////////////////////////////////////////////////////////// -/// PARAMETERS /// -//////////////////////////////////////////////////////////////////////// - -// uncomment to have fanouts represented in the mapping graph -//#define MAP_ALLOCATE_FANOUT 1 - -//////////////////////////////////////////////////////////////////////// -/// MACRO DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -// the bit masks -#define MAP_MASK(n) ((~((unsigned)0)) >> (32-(n))) -#define MAP_FULL (~((unsigned)0)) -#define MAP_NO_VAR (-9999.0) - -// maximum/minimum operators -#define MAP_MIN(a,b) (((a) < (b))? (a) : (b)) -#define MAP_MAX(a,b) (((a) > (b))? (a) : (b)) - -// the small and large numbers (min/max float are 1.17e-38/3.40e+38) -#define MAP_FLOAT_LARGE ((float)(FLT_MAX/10)) -#define MAP_FLOAT_SMALL ((float)1.0e-03) - -// generating random unsigned (#define RAND_MAX 0x7fff) -#define MAP_RANDOM_UNSIGNED ((((unsigned)rand()) << 24) ^ (((unsigned)rand()) << 12) ^ ((unsigned)rand())) - -// internal macros to work with cuts -#define Map_CutIsComplement(p) (((int)((unsigned long) (p) & 01))) -#define Map_CutRegular(p) ((Map_Cut_t *)((unsigned long)(p) & ~01)) -#define Map_CutNot(p) ((Map_Cut_t *)((unsigned long)(p) ^ 01)) -#define Map_CutNotCond(p,c) ((Map_Cut_t *)((unsigned long)(p) ^ (c))) - -// internal macros for referencing of nodes -#define Map_NodeReadRef(p) ((Map_Regular(p))->nRefs) -#define Map_NodeRef(p) ((Map_Regular(p))->nRefs++) - -// macros to get hold of the bits in the support info -#define Map_InfoSetVar(p,i) (p[(i)>>5] |= (1<<((i) & 31))) -#define Map_InfoRemVar(p,i) (p[(i)>>5] &= ~(1<<((i) & 31))) -#define Map_InfoFlipVar(p,i) (p[(i)>>5] ^= (1<<((i) & 31))) -#define Map_InfoReadVar(p,i) ((p[(i)>>5] & (1<<((i) & 31))) > 0) - -// returns the complemented attribute of the node -#define Map_NodeIsSimComplement(p) (Map_IsComplement(p)? !(Map_Regular(p)->fInv) : (p)->fInv) - -//////////////////////////////////////////////////////////////////////// -/// STRUCTURE DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -// the mapping manager -struct Map_ManStruct_t_ -{ - // the mapping graph - Map_Node_t ** pBins; // the table of nodes hashed by their children - int nBins; // the size of the table - Map_Node_t ** pInputs; // the array of inputs - int nInputs; // the number of inputs - Map_Node_t ** pOutputs; // the array of outputs - int nOutputs; // the number of outputs - int nNodes; // the total number of nodes - Map_Node_t * pConst1; // the constant 1 node - Map_NodeVec_t * vAnds; // the array of nodes in the DFS order - Map_NodeVec_t * vNodesAll; // the array of all nodes - Map_NodeVec_t * vNodesTemp; // the array of all nodes - Map_NodeVec_t * vMapping; // the array of internal nodes used in the mapping - - // info about the original circuit - char ** ppOutputNames; // the primary output names - Map_Time_t * pInputArrivals;// the PI arrival times - - // mapping parameters - int nVarsMax; // the max number of variables - int fAreaRecovery; // the flag to enable area recovery - int fVerbose; // the verbosiness flag - int fMappingMode; // set to 1 when doing area - float fRequiredGlo; // the global required times - float fEpsilon; // the epsilon used to compare floats - float AreaBase; // the area after delay-oriented mapping - float AreaFinal; // the area after delay-oriented mapping - int nIterations; // How many matching passes to do - bool fObeyFanoutLimits;// Should mapper try to obey fanout limits or not - float DelayTarget; // the required times set by the user - int nTravIds; // the traversal counter - bool fSwitching; // Should mapper try to obey fanout limits or not - - // the supergate library - Map_SuperLib_t * pSuperLib; // the current supergate library - unsigned uTruths[6][2]; // the elementary truth tables - unsigned uTruthsLarge[10][32]; // the elementary truth tables - int nCounts[32]; // the counter of minterms - int nCountsBest[32];// the counter of minterms - Map_NodeVec_t * vVisited; // the visited cuts during cut computation - - // the memory managers - Extra_MmFixed_t * mmNodes; // the memory manager for nodes - Extra_MmFixed_t * mmCuts; // the memory manager for cuts - - // precomputed N-canonical forms - unsigned short * uCanons; // N-canonical forms - char ** uPhases; // N-canonical phases - char * pCounters; // counters of phases - - // various statistical variables - int nChoiceNodes; // the number of choice nodes - int nChoices; // the number of all choices - int nCanons; // the number of times N-canonical form was computed - int nMatches; // the number of times supergate matching was performed - int nPhases; // the number of phases considered during matching - int nFanoutViolations; // the number of nodes in mapped circuit violating fanout - - // runtime statistics - int timeToMap; // time to transfer to the mapping structure - int timeCuts; // time to compute k-feasible cuts - int timeTruth; // time to compute the truth table for each cut - int timeMatch; // time to perform matching for each node - int timeArea; // time to recover area after delay oriented mapping - int timeSweep; // time to perform technology dependent sweep - int timeToNet; // time to transfer back to the network - int timeTotal; // the total mapping time - int time1; // time to transfer to the mapping structure - int time2; // time to transfer to the mapping structure - int time3; // time to transfer to the mapping structure -}; - -// the supergate library -struct Map_SuperLibStruct_t_ -{ - // general info - char * pName; // the name of the supergate library - Mio_Library_t * pGenlib; // the generic library - - // other info - int nVarsMax; // the max number of variables - int nSupersAll; // the total number of supergates - int nSupersReal; // the total number of supergates - int nLines; // the total number of lines in the supergate file - bool fVerbose; // the verbosity flag - - // hash tables - Map_Super_t ** ppSupers; // the array of supergates - Map_HashTable_t * tTableC; // the table mapping N-canonical forms into supergates - Map_HashTable_t * tTable; // the table mapping truth tables into supergates - - // data structures for N-canonical form computation - unsigned uTruths[6][2]; // the elementary truth tables - unsigned uMask[2]; // the mask for the truth table - - // the invertor - Mio_Gate_t * pGateInv; // the pointer to the intertor gate - Map_Time_t tDelayInv; // the delay of the inverter - float AreaInv; // the area of the inverter - float AreaBuf; // the area of the buffer - Map_Super_t * pSuperInv; // the supergate representing the inverter - - // the memory manager for the internal table - Extra_MmFixed_t * mmSupers; // the mamory manager for supergates - Extra_MmFixed_t * mmEntries; // the memory manager for the entries - Extra_MmFlex_t * mmForms; // the memory manager for formulas -}; - -// the mapping node -struct Map_NodeStruct_t_ -{ - // general information about the node - Map_Man_t * p; // the mapping manager - Map_Node_t * pNext; // the next node in the hash table - int Num; // the unique number of this node - int TravId; // the traversal ID (use to avoid cleaning marks) - int nRefs; // the number of references (fanouts) of the given node - unsigned fMark0 : 1; // the mark used for traversals - unsigned fMark1 : 1; // the mark used for traversals - unsigned fUsed : 1; // the mark to mark the node or its fanins - unsigned fInv : 1; // the complemented attribute for the equivalent nodes - unsigned fInvert: 1; // the flag to denote the use of interter - unsigned Level :16; // the level of the given node - unsigned NumTemp:10; // the level of the given node - int nRefAct[3]; // estimated fanout for current covering phase, neg and pos and sum - float nRefEst[3]; // actual fanout for previous covering phase, neg and pos and sum - float Switching; // the probability of switching - - // connectivity - Map_Node_t * p1; // the first child - Map_Node_t * p2; // the second child - Map_Node_t * pNextE; // the next functionally equivalent node - Map_Node_t * pRepr; // the representative of the functionally equivalent class - -#ifdef MAP_ALLOCATE_FANOUT - // representation of node's fanouts - Map_Node_t * pFanPivot; // the first fanout of this node - Map_Node_t * pFanFanin1; // the next fanout of p1 - Map_Node_t * pFanFanin2; // the next fanout of p2 -// Map_NodeVec_t * vFanouts; // the array of fanouts of the gate -#endif - - // the delay information - Map_Time_t tArrival[2]; // the best arrival time of the neg (0) and pos (1) phases - Map_Time_t tRequired[2]; // the required time of the neg (0) and pos (1) phases - - // misc information - Map_Cut_t * pCutBest[2]; // the best mapping for neg and pos phase - Map_Cut_t * pCuts; // mapping choices for the node (elementary comes first) - char * pData0; // temporary storage for the corresponding network node - char * pData1; // temporary storage for the corresponding network node -}; - -// the match of the cut -struct Map_MatchStruct_t_ -{ - // information used for matching - Map_Super_t * pSupers; - unsigned uPhase; - // information about the best selected match - unsigned uPhaseBest; // the best phase (the EXOR of match's phase and gate's phase) - Map_Super_t * pSuperBest; // the best supergate matched - // the parameters of the match - Map_Time_t tArrive; // the arrival time of this match - float AreaFlow; // the area flow or area of this match -}; - -// the cuts used for matching -struct Map_CutStruct_t_ -{ - Map_Cut_t * pNext; // the pointer to the next cut in the list - Map_Cut_t * pOne; // the father of this cut - Map_Cut_t * pTwo; // the mother of this cut - Map_Node_t * ppLeaves[6]; // the leaves of this cut - unsigned uTruth; // truth table for five-input cuts - char nLeaves; // the number of leaves - char nVolume; // the volume of this cut - char fMark; // the mark to denote visited cut - char Phase; // the mark to denote complemented cut - Map_Match_t M[2]; // the matches for positive/negative phase -}; - -// the supergate internally represented -struct Map_SuperStruct_t_ -{ - int Num; // the ID of the supergate - unsigned fSuper : 1; // the flag to distinquish a real super from a fake one - unsigned fExclude: 1; // the flag if set causes gate to be excluded from being used for mapping - unsigned nFanins : 3; // the number of inputs - unsigned nGates : 3; // the number of gates inside this supergate - unsigned nFanLimit: 4; // the max number of fanout count - unsigned nSupers : 16; // the number of supergates in the list - unsigned nPhases : 4; // the number of phases for matching with canonical form - unsigned char uPhases[4]; // the maximum of 4 phases for matching with canonical form - int nUsed; // the number of times the supergate is used - Map_Super_t * pFanins[6]; // the fanins of the gate - Mio_Gate_t * pRoot; // the root gate - unsigned uTruth[2]; // the truth table - Map_Time_t tDelaysR[6]; // the pin-to-pin delay constraints for the rise of the output - Map_Time_t tDelaysF[6]; // the pin-to-pin delay constraints for the rise of the output - Map_Time_t tDelayMax; // the maximum delay - float Area; // the area - char * pFormula; // the symbolic formula - Map_Super_t * pNext; // the pointer to the next super in the list -}; - -// the vector of nodes -struct Map_NodeVecStruct_t_ -{ - Map_Node_t ** pArray; // the array of nodes - int nSize; // the number of entries in the array - int nCap; // the number of allocated entries -}; - -// the hash table -struct Map_HashTableStruct_t_ -{ - Map_HashEntry_t ** pBins; // the table bins - int nBins; // the size of the table - int nEntries; // the total number of entries in the table - Extra_MmFixed_t * mmMan; // the memory manager for entries -}; - -// the entry in the hash table -struct Map_HashEntryStruct_t_ -{ - unsigned uTruth[2]; // the truth table for 6-var function - unsigned uPhase; // the phase to tranform it into the canonical form - Map_Super_t * pGates; // the linked list of matching supergates - Map_HashEntry_t * pNext; // the next entry in the hash table -}; - -// getting hold of the next fanout of the node -#define Map_NodeReadNextFanout( pNode, pFanout ) \ - ( ( pFanout == NULL )? NULL : \ - ((Map_Regular((pFanout)->p1) == (pNode))? \ - (pFanout)->pFanFanin1 : (pFanout)->pFanFanin2) ) - -// getting hold of the place where the next fanout will be attached -#define Map_NodeReadNextFanoutPlace( pNode, pFanout ) \ - ( (Map_Regular((pFanout)->p1) == (pNode))? \ - &(pFanout)->pFanFanin1 : &(pFanout)->pFanFanin2 ) - -// iterator through the fanouts of the node -#define Map_NodeForEachFanout( pNode, pFanout ) \ - for ( pFanout = (pNode)->pFanPivot; pFanout; \ - pFanout = Map_NodeReadNextFanout(pNode, pFanout) ) - -// safe iterator through the fanouts of the node -#define Map_NodeForEachFanoutSafe( pNode, pFanout, pFanout2 ) \ - for ( pFanout = (pNode)->pFanPivot, \ - pFanout2 = Map_NodeReadNextFanout(pNode, pFanout); \ - pFanout; \ - pFanout = pFanout2, \ - pFanout2 = Map_NodeReadNextFanout(pNode, pFanout) ) - -//////////////////////////////////////////////////////////////////////// -/// GLOBAL VARIABLES /// -//////////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/*=== mapperCanon.c =============================================================*/ -/*=== mapperCut.c ===============================================================*/ -extern void Map_MappingCuts( Map_Man_t * p ); -extern int Map_MappingCountAllCuts( Map_Man_t * p ); -/*=== mapperCutDcs.c ===============================================================*/ -extern void Map_ComputeDcs( Map_Man_t * p ); -extern unsigned Map_ComputeIsop_rec( Map_Man_t * p, unsigned uF, unsigned uFD, int iVar, int nVars, int fDir ); -/*=== mapperCutUtils.c ===============================================================*/ -extern Map_Cut_t * Map_CutAlloc( Map_Man_t * p ); -extern void Map_CutFree( Map_Man_t * p, Map_Cut_t * pCut ); -extern void Map_CutPrint( Map_Man_t * p, Map_Node_t * pRoot, Map_Cut_t * pCut, int fPhase ); -extern float Map_CutGetRootArea( Map_Cut_t * pCut, int fPhase ); -extern int Map_CutGetLeafPhase( Map_Cut_t * pCut, int fPhase, int iLeaf ); -extern int Map_NodeGetLeafPhase( Map_Node_t * pNode, int fPhase, int iLeaf ); -extern Map_Cut_t * Map_CutListAppend( Map_Cut_t * pSetAll, Map_Cut_t * pSets ); -extern void Map_CutListRecycle( Map_Man_t * p, Map_Cut_t * pSetList, Map_Cut_t * pSave ); -extern int Map_CutListCount( Map_Cut_t * pSets ); -extern void Map_CutRemoveFanouts( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase ); -extern void Map_CutInsertFanouts( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase ); -/*=== mapperFanout.c =============================================================*/ -extern void Map_NodeAddFaninFanout( Map_Node_t * pFanin, Map_Node_t * pFanout ); -extern void Map_NodeRemoveFaninFanout( Map_Node_t * pFanin, Map_Node_t * pFanoutToRemove ); -extern int Map_NodeGetFanoutNum( Map_Node_t * pNode ); -/*=== mapperLib.c ============================================================*/ -extern Map_SuperLib_t * Map_SuperLibCreate( char * pFileName, char * pExcludeFile, bool fAlgorithm, bool fVerbose ); -extern void Map_SuperLibFree( Map_SuperLib_t * p ); -/*=== mapperMatch.c ===============================================================*/ -extern int Map_MappingMatches( Map_Man_t * p ); -extern float Map_MappingCombinePhases( Map_Man_t * p ); -extern void Map_MatchClean( Map_Match_t * pMatch ); -extern int Map_MatchCompare( Map_Man_t * pMan, Map_Match_t * pM1, Map_Match_t * pM2, int fDoingArea ); -/*=== mapperPower.c =============================================================*/ -extern float Map_SwitchCutGetDerefed( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase ); -extern float Map_SwitchCutRef( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase ); -extern float Map_SwitchCutDeref( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase ); -extern float Map_MappingGetSwitching( Map_Man_t * pMan, Map_NodeVec_t * vMapping ); -/*=== mapperRefs.c =============================================================*/ -extern int Map_NodeReadRefPhaseAct( Map_Node_t * pNode, int fPhase ); -extern float Map_NodeReadRefPhaseEst( Map_Node_t * pNode, int fPhase ); -extern void Map_MappingEstimateRefsInit( Map_Man_t * p ); -extern void Map_MappingEstimateRefs( Map_Man_t * p ); -extern float Map_CutGetAreaFlow( Map_Cut_t * pCut, int fPhase ); -extern float Map_CutGetAreaRefed( Map_Cut_t * pCut, int fPhase ); -extern float Map_CutGetAreaDerefed( Map_Cut_t * pCut, int fPhase ); -extern float Map_CutRef( Map_Cut_t * pCut, int fPhase ); -extern float Map_CutDeref( Map_Cut_t * pCut, int fPhase ); -extern void Map_MappingSetRefs( Map_Man_t * pMan ); -extern float Map_MappingGetArea( Map_Man_t * pMan, Map_NodeVec_t * vMapping ); -/*=== mapperShow.c =============================================================*/ -extern void Map_MappingShow( Map_Man_t * pMan, char * pFileName ); -/*=== mapperTree.c ===============================================================*/ -extern int Map_LibraryReadTree( Map_SuperLib_t * pLib, char * pFileName, char * pExcludeFile ); -extern void Map_LibraryPrintTree( Map_SuperLib_t * pLib ); -/*=== mapperSuper.c ===============================================================*/ -extern int Map_LibraryRead( Map_SuperLib_t * p, char * pFileName ); -extern void Map_LibraryPrintSupergate( Map_Super_t * pGate ); -/*=== mapperTable.c ============================================================*/ -extern Map_HashTable_t * Map_SuperTableCreate( Map_SuperLib_t * pLib ); -extern void Map_SuperTableFree( Map_HashTable_t * p ); -extern int Map_SuperTableInsertC( Map_HashTable_t * pLib, unsigned uTruthC[], Map_Super_t * pGate ); -extern int Map_SuperTableInsert( Map_HashTable_t * pLib, unsigned uTruth[], Map_Super_t * pGate, unsigned uPhase ); -extern Map_Super_t * Map_SuperTableLookup( Map_HashTable_t * p, unsigned uTruth[], unsigned * puPhase ); -extern void Map_SuperTableSortSupergates( Map_HashTable_t * p, int nSupersMax ); -extern void Map_SuperTableSortSupergatesByDelay( Map_HashTable_t * p, int nSupersMax ); -/*=== mapperTime.c =============================================================*/ -extern float Map_TimeCutComputeArrival( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase, float tWorstCaseLimit ); -extern void Map_TimeCutComputeArrival_rec( Map_Cut_t * pCut, int fPhase ); -extern float Map_TimeComputeArrivalMax( Map_Man_t * p ); -extern void Map_TimeComputeRequiredGlobal( Map_Man_t * p ); -extern void Map_TimeComputeRequired( Map_Man_t * p, float fRequired ); -extern float Map_TimeNodeFanoutDelay( Map_Node_t * pNode, int fPhase ); -extern float Map_TimeCutFanoutDelay( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase ); -extern float Map_TimeMatchWithInverter( Map_Man_t * p, Map_Match_t * pMatch ); -/*=== mapperTruth.c ===============================================================*/ -extern void Map_MappingTruths( Map_Man_t * pMan ); -extern int Map_TruthsCutDontCare( Map_Man_t * pMan, Map_Cut_t * pCut, unsigned * uTruthDc ); -extern int Map_TruthCountOnes( unsigned * uTruth, int nLeaves ); -extern int Map_TruthDetectTwoFirst( unsigned * uTruth, int nLeaves ); -/*=== mapperUtils.c ===============================================================*/ -extern Map_NodeVec_t * Map_MappingDfs( Map_Man_t * pMan, int fCollectEquiv ); -extern Map_NodeVec_t * Map_MappingDfsNodes( Map_Man_t * pMan, Map_Node_t ** ppNodes, int nNodes, int fEquiv ); - -extern void Map_MappingDfsMarked1_rec( Map_Node_t * pNode, Map_NodeVec_t * vNodes, int fFirst ); -extern void Map_MappingDfsMarked2_rec( Map_Node_t * pNode, Map_NodeVec_t * vNodes, Map_NodeVec_t * vBoundary, int fFirst ); - -extern int Map_MappingCountLevels( Map_Man_t * pMan ); -extern void Map_MappingUnmark( Map_Man_t * pMan ); -extern void Map_MappingMark_rec( Map_Node_t * pNode ); -extern void Map_MappingUnmark_rec( Map_Node_t * pNode ); -extern void Map_MappingPrintOutputArrivals( Map_Man_t * p ); -extern void Map_MappingSetupMask( unsigned uMask[], int nVarsMax ); -extern int Map_MappingNodeIsViolator( Map_Node_t * pNode, Map_Cut_t * pCut, int fPosPol ); -extern float Map_MappingGetAreaFlow( Map_Man_t * p ); -extern void Map_MappingSortByLevel( Map_Man_t * pMan, Map_NodeVec_t * vNodes ); -extern int Map_MappingCountDoubles( Map_Man_t * pMan, Map_NodeVec_t * vNodes ); -extern void Map_MappingExpandTruth( unsigned uTruth[2], int nVars ); -extern float Map_MappingPrintSwitching( Map_Man_t * pMan ); -extern void Map_MappingSetPlacementInfo( Map_Man_t * p ); -extern float Map_MappingPrintWirelength( Map_Man_t * p ); -extern void Map_MappingWireReport( Map_Man_t * p ); -extern float Map_MappingComputeDelayWithFanouts( Map_Man_t * p ); -extern int Map_MappingGetMaxLevel( Map_Man_t * pMan ); -extern void Map_MappingSetChoiceLevels( Map_Man_t * pMan ); -extern void Map_MappingReportChoices( Map_Man_t * pMan ); -/*=== mapperVec.c =============================================================*/ -extern Map_NodeVec_t * Map_NodeVecAlloc( int nCap ); -extern void Map_NodeVecFree( Map_NodeVec_t * p ); -extern Map_Node_t ** Map_NodeVecReadArray( Map_NodeVec_t * p ); -extern int Map_NodeVecReadSize( Map_NodeVec_t * p ); -extern void Map_NodeVecGrow( Map_NodeVec_t * p, int nCapMin ); -extern void Map_NodeVecShrink( Map_NodeVec_t * p, int nSizeNew ); -extern void Map_NodeVecClear( Map_NodeVec_t * p ); -extern void Map_NodeVecPush( Map_NodeVec_t * p, Map_Node_t * Entry ); -extern int Map_NodeVecPushUnique( Map_NodeVec_t * p, Map_Node_t * Entry ); -extern Map_Node_t * Map_NodeVecPop( Map_NodeVec_t * p ); -extern void Map_NodeVecRemove( Map_NodeVec_t * p, Map_Node_t * Entry ); -extern void Map_NodeVecWriteEntry( Map_NodeVec_t * p, int i, Map_Node_t * Entry ); -extern Map_Node_t * Map_NodeVecReadEntry( Map_NodeVec_t * p, int i ); -extern void Map_NodeVecSortByLevel( Map_NodeVec_t * p ); - -#endif - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// diff --git a/src/map/mapper/mapperLib.c b/src/map/mapper/mapperLib.c deleted file mode 100644 index d916487e..00000000 --- a/src/map/mapper/mapperLib.c +++ /dev/null @@ -1,231 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapperLib.c] - - PackageName [MVSIS 1.3: Multi-valued logic synthesis system.] - - Synopsis [Generic technology mapping engine.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 2.0. Started - June 1, 2004.] - - Revision [$Id: mapperLib.c,v 1.6 2005/01/23 06:59:44 alanmi Exp $] - -***********************************************************************/ - -#include "mapperInt.h" - -//////////////////////////////////////////////////////////////////////// -/// DECLARATIONS /// -//////////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**Function************************************************************* - - Synopsis [Reads in the supergate library and prepares it for use.] - - Description [The supergates library comes in a .super file. This file - contains descriptions of supergates along with some relevant information. - This procedure reads the supergate file, canonicizes the supergates, - and constructs an additional lookup table, which can be used to map - truth tables of the cuts into the pair (phase, supergate). The phase - indicates how the current truth table should be phase assigned to - match the canonical form of the supergate. The resulting phase is the - bitwise EXOR of the phase needed to canonicize the supergate and the - phase needed to transform the truth table into its canonical form.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_SuperLib_t * Map_SuperLibCreate( char * pFileName, char * pExcludeFile, bool fAlgorithm, bool fVerbose ) -{ - Map_SuperLib_t * p; - int clk; - - // start the supergate library - p = ALLOC( Map_SuperLib_t, 1 ); - memset( p, 0, sizeof(Map_SuperLib_t) ); - p->pName = pFileName; - p->fVerbose = fVerbose; - p->mmSupers = Extra_MmFixedStart( sizeof(Map_Super_t) ); - p->mmEntries = Extra_MmFixedStart( sizeof(Map_HashEntry_t) ); - p->mmForms = Extra_MmFlexStart(); - Map_MappingSetupTruthTables( p->uTruths ); - - // start the hash table - p->tTableC = Map_SuperTableCreate( p ); - p->tTable = Map_SuperTableCreate( p ); - - // read the supergate library from file -clk = clock(); - if ( fAlgorithm ) - { - if ( !Map_LibraryReadTree( p, pFileName, pExcludeFile ) ) - { - Map_SuperLibFree( p ); - return NULL; - } - } - else - { - if ( pExcludeFile != 0 ) - { - printf ("Error: Exclude file support not present for old format. Stop.\n"); - return NULL; - } - if ( !Map_LibraryRead( p, pFileName ) ) - { - Map_SuperLibFree( p ); - return NULL; - } - } - assert( p->nVarsMax > 0 ); - - // report the stats -if ( fVerbose ) { - printf( "Loaded %d unique %d-input supergates from \"%s\". ", - p->nSupersReal, p->nVarsMax, pFileName ); - PRT( "Time", clock() - clk ); -} - - // assign the interver parameters - p->pGateInv = Mio_LibraryReadInv( p->pGenlib ); - p->tDelayInv.Rise = Mio_LibraryReadDelayInvRise( p->pGenlib ); - p->tDelayInv.Fall = Mio_LibraryReadDelayInvFall( p->pGenlib ); - p->tDelayInv.Worst = MAP_MAX( p->tDelayInv.Rise, p->tDelayInv.Fall ); - p->AreaInv = Mio_LibraryReadAreaInv( p->pGenlib ); - p->AreaBuf = Mio_LibraryReadAreaBuf( p->pGenlib ); - - // assign the interver supergate - p->pSuperInv = (Map_Super_t *)Extra_MmFixedEntryFetch( p->mmSupers ); - memset( p->pSuperInv, 0, sizeof(Map_Super_t) ); - p->pSuperInv->Num = -1; - p->pSuperInv->nGates = 1; - p->pSuperInv->nFanins = 1; - p->pSuperInv->nFanLimit = 10; - p->pSuperInv->pFanins[0] = p->ppSupers[0]; - p->pSuperInv->pRoot = p->pGateInv; - p->pSuperInv->Area = p->AreaInv; - p->pSuperInv->tDelayMax = p->tDelayInv; - p->pSuperInv->tDelaysR[0].Rise = MAP_NO_VAR; - p->pSuperInv->tDelaysR[0].Fall = p->tDelayInv.Rise; - p->pSuperInv->tDelaysF[0].Rise = p->tDelayInv.Fall; - p->pSuperInv->tDelaysF[0].Fall = MAP_NO_VAR; - return p; -} - - -/**Function************************************************************* - - Synopsis [Deallocates the supergate library.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_SuperLibFree( Map_SuperLib_t * p ) -{ - if ( p == NULL ) return; - if ( p->pGenlib ) - { - assert( p->pGenlib == Abc_FrameReadLibGen() ); - Mio_LibraryDelete( p->pGenlib ); - Abc_FrameSetLibGen( NULL ); - } - if ( p->tTableC ) - Map_SuperTableFree( p->tTableC ); - if ( p->tTable ) - Map_SuperTableFree( p->tTable ); - Extra_MmFixedStop( p->mmSupers ); - Extra_MmFixedStop( p->mmEntries ); - Extra_MmFlexStop( p->mmForms ); - FREE( p->ppSupers ); - FREE( p ); -} - -/**Function************************************************************* - - Synopsis [Derives the library from the genlib library.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_SuperLibDeriveFromGenlib( Mio_Library_t * pLib ) -{ - Abc_Frame_t * pAbc = Abc_FrameGetGlobalFrame(); - char * pNameGeneric; - char FileNameGenlib[100]; - char FileNameSuper[100]; - char CommandSuper[500]; - char CommandRead[500]; - FILE * pFile; - - if ( pLib == NULL ) - return 0; - - // write the current library into the file - sprintf( FileNameGenlib, "%s_temp", Mio_LibraryReadName(pLib) ); - pFile = fopen( FileNameGenlib, "w" ); - Mio_WriteLibrary( pFile, pLib, 0 ); - fclose( pFile ); - - // get the file name with the library - pNameGeneric = Extra_FileNameGeneric( Mio_LibraryReadName(pLib) ); - sprintf( FileNameSuper, "%s.super", pNameGeneric ); - free( pNameGeneric ); - - sprintf( CommandSuper, "super -l 1 -i 5 -d 10000000 -a 10000000 -t 100 %s", FileNameGenlib ); - if ( Cmd_CommandExecute( pAbc, CommandSuper ) ) - { - fprintf( stdout, "Cannot execute command \"%s\".\n", CommandSuper ); - return 0; - } -//#ifdef WIN32 -// _unlink( FileNameGenlib ); -//#else -// unlink( FileNameGenlib ); -//#endif - - sprintf( CommandRead, "read_super %s", FileNameSuper ); - if ( Cmd_CommandExecute( pAbc, CommandRead ) ) - { -#ifdef WIN32 - _unlink( FileNameSuper ); -#else - unlink( FileNameSuper ); -#endif - fprintf( stdout, "Cannot execute command \"%s\".\n", CommandRead ); - return 0; - } - -/* // don't remove the intermediate file -#ifdef WIN32 - _unlink( FileNameSuper ); -#else - unlink( FileNameSuper ); -#endif -*/ - return 1; -} - - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - - diff --git a/src/map/mapper/mapperMatch.c b/src/map/mapper/mapperMatch.c deleted file mode 100644 index bfa72601..00000000 --- a/src/map/mapper/mapperMatch.c +++ /dev/null @@ -1,596 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapperMatch.c] - - PackageName [MVSIS 1.3: Multi-valued logic synthesis system.] - - Synopsis [Generic technology mapping engine.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 2.0. Started - June 1, 2004.] - - Revision [$Id: mapperMatch.c,v 1.7 2004/09/30 21:18:10 satrajit Exp $] - -***********************************************************************/ - -#include "mapperInt.h" - -/* - A potential improvement: - When an internal node is not used in the mapping, its required times - are set to be +infinity. So when we recover area, we try to find the - best match for area and completely disregard the delay for the nodes - that are not currently used in the mapping because any match whose - arrival times are less than the required times (+infinity) can be used. - It may be possible to develop a better approach to recover area for - the nodes that are not currently used in the mapping... -*/ - -//////////////////////////////////////////////////////////////////////// -/// DECLARATIONS /// -//////////////////////////////////////////////////////////////////////// - -static int Map_MatchNodePhase( Map_Man_t * p, Map_Node_t * pNode, int fPhase ); -static int Map_MatchNodeCut( Map_Man_t * p, Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase, float fWorstLimit ); - -static void Map_MappingSetPiArrivalTimes( Map_Man_t * p ); -static void Map_NodeTryDroppingOnePhase( Map_Man_t * p, Map_Node_t * pNode ); -static void Map_NodeTransferArrivalTimes( Map_Man_t * p, Map_Node_t * pNode ); - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**Function************************************************************* - - Synopsis [Computes the best matches of the nodes.] - - Description [Uses parameter p->fMappingMode to decide how to assign - the matches for both polarities of the node. While the matches are - being assigned, one of them may turn out to be better than the other - (in terms of delay, for example). In this case, the worse match can - be permanently dropped, and the corresponding pointer set to NULL.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_MappingMatches( Map_Man_t * p ) -{ - ProgressBar * pProgress; - Map_Node_t * pNode; - int i; - - assert( p->fMappingMode >= 0 && p->fMappingMode <= 4 ); - - // use the externally given PI arrival times - if ( p->fMappingMode == 0 ) - Map_MappingSetPiArrivalTimes( p ); - - // estimate the fanouts - if ( p->fMappingMode == 0 ) - Map_MappingEstimateRefsInit( p ); - else if ( p->fMappingMode == 1 ) - Map_MappingEstimateRefs( p ); - - // the PI cuts are matched in the cut computation package - // in the loop below we match the internal nodes - pProgress = Extra_ProgressBarStart( stdout, p->vAnds->nSize ); - for ( i = 0; i < p->vAnds->nSize; i++ ) - { - // skip primary inputs and secondary nodes if mapping with choices - pNode = p->vAnds->pArray[i]; - if ( !Map_NodeIsAnd( pNode ) || pNode->pRepr ) - continue; - - // make sure that at least one non-trival cut is present - if ( pNode->pCuts->pNext == NULL ) - { - printf( "\nError: A node in the mapping graph does not have feasible cuts.\n" ); - return 0; - } - - // match negative phase - if ( !Map_MatchNodePhase( p, pNode, 0 ) ) - return 0; - // match positive phase - if ( !Map_MatchNodePhase( p, pNode, 1 ) ) - return 0; - - // make sure that at least one phase is mapped - if ( pNode->pCutBest[0] == NULL && pNode->pCutBest[1] == NULL ) - { - printf( "\nError: Could not match both phases of AIG node %d.\n", pNode->Num ); - printf( "Please make sure that the supergate library has equivalents of AND2 or NAND2.\n" ); - printf( "If such supergates exist in the library, report a bug.\n" ); - return 0; - } - - // if both phases are assigned, check if one of them can be dropped - Map_NodeTryDroppingOnePhase( p, pNode ); - // set the arrival times of the node using the best cuts - Map_NodeTransferArrivalTimes( p, pNode ); - - // update the progress bar - Extra_ProgressBarUpdate( pProgress, i, "Matches ..." ); - } - Extra_ProgressBarStop( pProgress ); - return 1; -} - -/**Function************************************************************* - - Synopsis [Find the matching of one polarity of the node.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_MatchNodePhase( Map_Man_t * p, Map_Node_t * pNode, int fPhase ) -{ - Map_Match_t MatchBest, * pMatch; - Map_Cut_t * pCut, * pCutBest; - float Area1, Area2, fWorstLimit; - - // skip the cuts that have been unassigned during area recovery - pCutBest = pNode->pCutBest[fPhase]; - if ( p->fMappingMode != 0 && pCutBest == NULL ) - return 1; - - // recompute the arrival times of the current best match - // because the arrival times of the fanins may have changed - // as a result of remapping fanins in the topological order - if ( p->fMappingMode != 0 ) - { - Map_TimeCutComputeArrival( pNode, pCutBest, fPhase, MAP_FLOAT_LARGE ); - // make sure that the required times are met - assert( pCutBest->M[fPhase].tArrive.Rise < pNode->tRequired[fPhase].Rise + p->fEpsilon ); - assert( pCutBest->M[fPhase].tArrive.Fall < pNode->tRequired[fPhase].Fall + p->fEpsilon ); - } - - // recompute the exact area of the current best match - // because the exact area of the fanins may have changed - // as a result of remapping fanins in the topological order - if ( p->fMappingMode == 2 || p->fMappingMode == 3 ) - { - pMatch = pCutBest->M + fPhase; - if ( pNode->nRefAct[fPhase] > 0 || - (pNode->pCutBest[!fPhase] == NULL && pNode->nRefAct[!fPhase] > 0) ) - pMatch->AreaFlow = Area1 = Map_CutDeref( pCutBest, fPhase ); - else - pMatch->AreaFlow = Area1 = Map_CutGetAreaDerefed( pCutBest, fPhase ); - } - else if ( p->fMappingMode == 4 ) - { - pMatch = pCutBest->M + fPhase; - if ( pNode->nRefAct[fPhase] > 0 || - (pNode->pCutBest[!fPhase] == NULL && pNode->nRefAct[!fPhase] > 0) ) - pMatch->AreaFlow = Area1 = Map_SwitchCutDeref( pNode, pCutBest, fPhase ); - else - pMatch->AreaFlow = Area1 = Map_SwitchCutGetDerefed( pNode, pCutBest, fPhase ); - } - - // save the old mapping - if ( pCutBest ) - MatchBest = pCutBest->M[fPhase]; - else - Map_MatchClean( &MatchBest ); - - // select the new best cut - fWorstLimit = pNode->tRequired[fPhase].Worst; - for ( pCut = pNode->pCuts->pNext; pCut; pCut = pCut->pNext ) - { - pMatch = pCut->M + fPhase; - if ( pMatch->pSupers == NULL ) - continue; - - // find the matches for the cut - Map_MatchNodeCut( p, pNode, pCut, fPhase, fWorstLimit ); - if ( pMatch->pSuperBest == NULL || pMatch->tArrive.Worst > fWorstLimit + p->fEpsilon ) - continue; - - // if the cut can be matched compare the matchings - if ( Map_MatchCompare( p, &MatchBest, pMatch, p->fMappingMode ) ) - { - pCutBest = pCut; - MatchBest = *pMatch; - // if we are mapping for delay, the worst-case limit should be tightened - if ( p->fMappingMode == 0 ) - fWorstLimit = MatchBest.tArrive.Worst; - } - } - - if ( pCutBest == NULL ) - return 1; - - // set the new mapping - pNode->pCutBest[fPhase] = pCutBest; - pCutBest->M[fPhase] = MatchBest; - - // reference the new cut if it used - if ( p->fMappingMode >= 2 && - (pNode->nRefAct[fPhase] > 0 || - (pNode->pCutBest[!fPhase] == NULL && pNode->nRefAct[!fPhase] > 0)) ) - { - if ( p->fMappingMode == 2 || p->fMappingMode == 3 ) - Area2 = Map_CutRef( pNode->pCutBest[fPhase], fPhase ); - else if ( p->fMappingMode == 4 ) - Area2 = Map_SwitchCutRef( pNode, pNode->pCutBest[fPhase], fPhase ); - else - assert( 0 ); - assert( Area2 < Area1 + p->fEpsilon ); - } - - // make sure that the requited times are met - assert( MatchBest.tArrive.Rise < pNode->tRequired[fPhase].Rise + p->fEpsilon ); - assert( MatchBest.tArrive.Fall < pNode->tRequired[fPhase].Fall + p->fEpsilon ); - return 1; -} - -/**Function************************************************************* - - Synopsis [Find the best matching of the cut.] - - Description [The parameters: the node (pNode), the cut (pCut), the phase to be matched - (fPhase), and the upper bound on the arrival times of the cut (fWorstLimit). This - procedure goes through the matching supergates up to the phase assignment, and selects the - best supergate, which will be used to map the cut. As a result of calling this procedure - the matching information is written into pMatch.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_MatchNodeCut( Map_Man_t * p, Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase, float fWorstLimit ) -{ - Map_Match_t MatchBest, * pMatch = pCut->M + fPhase; - Map_Super_t * pSuper; - int i, Counter; - - // save the current match of the cut - MatchBest = *pMatch; - // go through the supergates - for ( pSuper = pMatch->pSupers, Counter = 0; pSuper; pSuper = pSuper->pNext, Counter++ ) - { - p->nMatches++; - // this is an attempt to reduce the runtime of matching and area - // at the cost of rare and very minor increase in delay - // (the supergates are sorted by increasing area) - if ( Counter == 30 ) - break; - - // go through different phases of the given match and supergate - pMatch->pSuperBest = pSuper; - for ( i = 0; i < (int)pSuper->nPhases; i++ ) - { - p->nPhases++; - // find the overall phase of this match - pMatch->uPhaseBest = pMatch->uPhase ^ pSuper->uPhases[i]; - if ( p->fMappingMode == 0 ) - { - // get the arrival time - Map_TimeCutComputeArrival( pNode, pCut, fPhase, fWorstLimit ); - // skip the cut if the arrival times exceed the required times - if ( pMatch->tArrive.Worst > fWorstLimit + p->fEpsilon ) - continue; - // get the area (area flow) - pMatch->AreaFlow = Map_CutGetAreaFlow( pCut, fPhase ); - } - else - { - // get the area (area flow) - if ( p->fMappingMode == 2 || p->fMappingMode == 3 ) - pMatch->AreaFlow = Map_CutGetAreaDerefed( pCut, fPhase ); - else if ( p->fMappingMode == 4 ) - pMatch->AreaFlow = Map_SwitchCutGetDerefed( pNode, pCut, fPhase ); - else - pMatch->AreaFlow = Map_CutGetAreaFlow( pCut, fPhase ); - // skip if the cut is too large - if ( pMatch->AreaFlow > MatchBest.AreaFlow + p->fEpsilon ) - continue; - // get the arrival time - Map_TimeCutComputeArrival( pNode, pCut, fPhase, fWorstLimit ); - // skip the cut if the arrival times exceed the required times - if ( pMatch->tArrive.Worst > fWorstLimit + p->fEpsilon ) - continue; - } - - // if the cut is non-trivial, compare it - if ( Map_MatchCompare( p, &MatchBest, pMatch, p->fMappingMode ) ) - { - MatchBest = *pMatch; - // if we are mapping for delay, the worst-case limit should be reduced - if ( p->fMappingMode == 0 ) - fWorstLimit = MatchBest.tArrive.Worst; - } - } - } - // set the best match - *pMatch = MatchBest; - - // recompute the arrival time and area (area flow) of this cut - if ( pMatch->pSuperBest ) - { - Map_TimeCutComputeArrival( pNode, pCut, fPhase, MAP_FLOAT_LARGE ); - if ( p->fMappingMode == 2 || p->fMappingMode == 3 ) - pMatch->AreaFlow = Map_CutGetAreaDerefed( pCut, fPhase ); - else if ( p->fMappingMode == 4 ) - pMatch->AreaFlow = Map_SwitchCutGetDerefed( pNode, pCut, fPhase ); - else - pMatch->AreaFlow = Map_CutGetAreaFlow( pCut, fPhase ); - } - return 1; -} - -/**Function************************************************************* - - Synopsis [Cleans the match.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MatchClean( Map_Match_t * pMatch ) -{ - memset( pMatch, 0, sizeof(Map_Match_t) ); - pMatch->AreaFlow = MAP_FLOAT_LARGE; // unassigned - pMatch->tArrive.Rise = MAP_FLOAT_LARGE; // unassigned - pMatch->tArrive.Fall = MAP_FLOAT_LARGE; // unassigned - pMatch->tArrive.Worst = MAP_FLOAT_LARGE; // unassigned -} - -/**Function************************************************************* - - Synopsis [Compares two matches.] - - Description [Returns 1 if the second match is better. Otherwise returns 0.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_MatchCompare( Map_Man_t * pMan, Map_Match_t * pM1, Map_Match_t * pM2, int fDoingArea ) -{ - if ( !fDoingArea ) - { - // compare the arrival times - if ( pM1->tArrive.Worst < pM2->tArrive.Worst - pMan->fEpsilon ) - return 0; - if ( pM1->tArrive.Worst > pM2->tArrive.Worst + pMan->fEpsilon ) - return 1; - // compare the areas or area flows - if ( pM1->AreaFlow < pM2->AreaFlow - pMan->fEpsilon ) - return 0; - if ( pM1->AreaFlow > pM2->AreaFlow + pMan->fEpsilon ) - return 1; - // compare the fanout limits - if ( pM1->pSuperBest->nFanLimit > pM2->pSuperBest->nFanLimit ) - return 0; - if ( pM1->pSuperBest->nFanLimit < pM2->pSuperBest->nFanLimit ) - return 1; - // compare the number of leaves - if ( pM1->pSuperBest->nFanins < pM2->pSuperBest->nFanins ) - return 0; - if ( pM1->pSuperBest->nFanins > pM2->pSuperBest->nFanins ) - return 1; - // otherwise prefer the old cut - return 0; - } - else - { - // compare the areas or area flows - if ( pM1->AreaFlow < pM2->AreaFlow - pMan->fEpsilon ) - return 0; - if ( pM1->AreaFlow > pM2->AreaFlow + pMan->fEpsilon ) - return 1; - // compare the arrival times - if ( pM1->tArrive.Worst < pM2->tArrive.Worst - pMan->fEpsilon ) - return 0; - if ( pM1->tArrive.Worst > pM2->tArrive.Worst + pMan->fEpsilon ) - return 1; - // compare the fanout limits - if ( pM1->pSuperBest->nFanLimit > pM2->pSuperBest->nFanLimit ) - return 0; - if ( pM1->pSuperBest->nFanLimit < pM2->pSuperBest->nFanLimit ) - return 1; - // compare the number of leaves - if ( pM1->pSuperBest->nFanins < pM2->pSuperBest->nFanins ) - return 0; - if ( pM1->pSuperBest->nFanins > pM2->pSuperBest->nFanins ) - return 1; - // otherwise prefer the old cut - return 0; - } -} - -/**Function************************************************************* - - Synopsis [Sets the PI arrival times.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingSetPiArrivalTimes( Map_Man_t * p ) -{ - Map_Node_t * pNode; - int i; - for ( i = 0; i < p->nInputs; i++ ) - { - pNode = p->pInputs[i]; - // set the arrival time of the positive phase - pNode->tArrival[1] = p->pInputArrivals[i]; - // set the arrival time of the negative phase - pNode->tArrival[0].Rise = pNode->tArrival[1].Fall + p->pSuperLib->tDelayInv.Rise; - pNode->tArrival[0].Fall = pNode->tArrival[1].Rise + p->pSuperLib->tDelayInv.Fall; - pNode->tArrival[0].Worst = MAP_MAX(pNode->tArrival[0].Rise, pNode->tArrival[0].Fall); - } -} - - -/**Function************************************************************* - - Synopsis [Attempts dropping one phase of the node.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_NodeTryDroppingOnePhase( Map_Man_t * p, Map_Node_t * pNode ) -{ - Map_Match_t * pMatchBest0, * pMatchBest1; - float tWorst0Using1, tWorst1Using0; - int fUsePhase1, fUsePhase0; - - // nothing to do if one of the phases is already dropped - if ( pNode->pCutBest[0] == NULL || pNode->pCutBest[1] == NULL ) - return; - - // do not drop while recovering area flow - if ( p->fMappingMode == 1 )//|| p->fMappingMode == 2 ) - return; - - // get the pointers to the matches of the best cuts - pMatchBest0 = pNode->pCutBest[0]->M + 0; - pMatchBest1 = pNode->pCutBest[1]->M + 1; - - // get the worst arrival times of each phase - // implemented using the other phase with inverter added - tWorst0Using1 = Map_TimeMatchWithInverter( p, pMatchBest1 ); - tWorst1Using0 = Map_TimeMatchWithInverter( p, pMatchBest0 ); - - // consider the case of mapping for delay - if ( p->fMappingMode == 0 ) - { - // if the arrival time of a phase is larger than the arrival time - // of the opposite phase plus the inverter, drop this phase - if ( pMatchBest0->tArrive.Worst > tWorst0Using1 + p->fEpsilon ) - pNode->pCutBest[0] = NULL; - else if ( pMatchBest1->tArrive.Worst > tWorst1Using0 + p->fEpsilon ) - pNode->pCutBest[1] = NULL; - return; - } - - // do not perform replacement if one of the phases is unused - if ( pNode->nRefAct[0] == 0 || pNode->nRefAct[1] == 0 ) - return; - - // check if replacement of each phase is possible using required times - fUsePhase0 = fUsePhase1 = 0; - if ( p->fMappingMode == 2 ) - { - fUsePhase0 = (pNode->tRequired[1].Worst > tWorst1Using0 + 3*p->pSuperLib->tDelayInv.Worst + p->fEpsilon); - fUsePhase1 = (pNode->tRequired[0].Worst > tWorst0Using1 + 3*p->pSuperLib->tDelayInv.Worst + p->fEpsilon); - } - else if ( p->fMappingMode == 3 || p->fMappingMode == 4 ) - { - fUsePhase0 = (pNode->tRequired[1].Worst > tWorst1Using0 + p->fEpsilon); - fUsePhase1 = (pNode->tRequired[0].Worst > tWorst0Using1 + p->fEpsilon); - } - if ( !fUsePhase0 && !fUsePhase1 ) - return; - - // if replacement is possible both ways, use the one that works better - if ( fUsePhase0 && fUsePhase1 ) - { - if ( pMatchBest0->AreaFlow < pMatchBest1->AreaFlow ) - fUsePhase1 = 0; - else - fUsePhase0 = 0; - } - // only one phase should be used - assert( fUsePhase0 ^ fUsePhase1 ); - - // set the corresponding cut to NULL - if ( fUsePhase0 ) - { - // deref phase 1 cut if necessary - if ( p->fMappingMode >= 2 && pNode->nRefAct[1] > 0 ) - Map_CutDeref( pNode->pCutBest[1], 1 ); - // get rid of the cut - pNode->pCutBest[1] = NULL; - // ref phase 0 cut if necessary - if ( p->fMappingMode >= 2 && pNode->nRefAct[0] == 0 ) - Map_CutRef( pNode->pCutBest[0], 0 ); - } - else - { - // deref phase 0 cut if necessary - if ( p->fMappingMode >= 2 && pNode->nRefAct[0] > 0 ) - Map_CutDeref( pNode->pCutBest[0], 0 ); - // get rid of the cut - pNode->pCutBest[0] = NULL; - // ref phase 1 cut if necessary - if ( p->fMappingMode >= 2 && pNode->nRefAct[1] == 0 ) - Map_CutRef( pNode->pCutBest[1], 1 ); - } -} - - -/**Function************************************************************* - - Synopsis [Transfers the arrival times from the best cuts to the node.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_NodeTransferArrivalTimes( Map_Man_t * p, Map_Node_t * pNode ) -{ - // if both phases are available, set their arrival times - if ( pNode->pCutBest[0] && pNode->pCutBest[1] ) - { - pNode->tArrival[0] = pNode->pCutBest[0]->M[0].tArrive; - pNode->tArrival[1] = pNode->pCutBest[1]->M[1].tArrive; - } - // if only one phase is available, compute the arrival time of other phase - else if ( pNode->pCutBest[0] ) - { - pNode->tArrival[0] = pNode->pCutBest[0]->M[0].tArrive; - pNode->tArrival[1].Rise = pNode->tArrival[0].Fall + p->pSuperLib->tDelayInv.Rise; - pNode->tArrival[1].Fall = pNode->tArrival[0].Rise + p->pSuperLib->tDelayInv.Fall; - pNode->tArrival[1].Worst = MAP_MAX(pNode->tArrival[1].Rise, pNode->tArrival[1].Fall); - } - else if ( pNode->pCutBest[1] ) - { - pNode->tArrival[1] = pNode->pCutBest[1]->M[1].tArrive; - pNode->tArrival[0].Rise = pNode->tArrival[1].Fall + p->pSuperLib->tDelayInv.Rise; - pNode->tArrival[0].Fall = pNode->tArrival[1].Rise + p->pSuperLib->tDelayInv.Fall; - pNode->tArrival[0].Worst = MAP_MAX(pNode->tArrival[0].Rise, pNode->tArrival[0].Fall); - } - else - { - assert( 0 ); - } - - assert( pNode->tArrival[0].Rise < pNode->tRequired[0].Rise + p->fEpsilon ); - assert( pNode->tArrival[0].Fall < pNode->tRequired[0].Fall + p->fEpsilon ); - - assert( pNode->tArrival[1].Rise < pNode->tRequired[1].Rise + p->fEpsilon ); - assert( pNode->tArrival[1].Fall < pNode->tRequired[1].Fall + p->fEpsilon ); -} - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// diff --git a/src/map/mapper/mapperRefs.c b/src/map/mapper/mapperRefs.c deleted file mode 100644 index a50b134a..00000000 --- a/src/map/mapper/mapperRefs.c +++ /dev/null @@ -1,557 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapperRefs.c] - - PackageName [MVSIS 1.3: Multi-valued logic synthesis system.] - - Synopsis [Generic technology mapping engine.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 2.0. Started - June 1, 2004.] - - Revision [$Id: mapperRefs.h,v 1.0 2003/09/08 00:00:00 alanmi Exp $] - -***********************************************************************/ - -#include "mapperInt.h" - -//////////////////////////////////////////////////////////////////////// -/// DECLARATIONS /// -//////////////////////////////////////////////////////////////////////// - -static int Map_NodeIncRefPhaseAct( Map_Node_t * pNode, int fPhase ); -static int Map_NodeDecRefPhaseAct( Map_Node_t * pNode, int fPhase ); -static float Map_CutRefDeref( Map_Cut_t * pCut, int fPhase, int fReference ); -static void Map_MappingSetRefs_rec( Map_Man_t * pMan, Map_Node_t * pNode, Map_Node_t ** ppStore ); - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**Function************************************************************* - - Synopsis [Reads the actual reference counter of a phase.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_NodeReadRefPhaseAct( Map_Node_t * pNode, int fPhase ) -{ - assert( !Map_IsComplement(pNode) ); - if ( pNode->pCutBest[0] && pNode->pCutBest[1] ) // both assigned - return pNode->nRefAct[fPhase]; - assert( pNode->pCutBest[0] || pNode->pCutBest[1] ); // at least one assigned - return pNode->nRefAct[2]; -} - -/**Function************************************************************* - - Synopsis [Reads the estimated reference counter of a phase.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -float Map_NodeReadRefPhaseEst( Map_Node_t * pNode, int fPhase ) -{ - assert( !Map_IsComplement(pNode) ); - if ( pNode->pCutBest[0] && pNode->pCutBest[1] ) // both assigned - return pNode->nRefEst[fPhase]; - assert( pNode->pCutBest[0] || pNode->pCutBest[1] ); // at least one assigned -// return pNode->nRefEst[0] + pNode->nRefEst[1]; - return pNode->nRefEst[2]; -} - - -/**Function************************************************************* - - Synopsis [Increments the actual reference counter of a phase.] - - Description [Returns the old reference counter.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_NodeIncRefPhaseAct( Map_Node_t * pNode, int fPhase ) -{ - assert( !Map_IsComplement(pNode) ); - if ( pNode->pCutBest[0] && pNode->pCutBest[1] ) // both assigned - return pNode->nRefAct[fPhase]++; - assert( pNode->pCutBest[0] || pNode->pCutBest[1] ); // at least one assigned - return pNode->nRefAct[2]++; -} - -/**Function************************************************************* - - Synopsis [Decrements the actual reference counter of a phase.] - - Description [Returns the new reference counter.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_NodeDecRefPhaseAct( Map_Node_t * pNode, int fPhase ) -{ - assert( !Map_IsComplement(pNode) ); - if ( pNode->pCutBest[0] && pNode->pCutBest[1] ) // both assigned - return --pNode->nRefAct[fPhase]; - assert( pNode->pCutBest[0] || pNode->pCutBest[1] ); // at least one assigned - return --pNode->nRefAct[2]; -} - - -/**Function************************************************************* - - Synopsis [Sets the estimated reference counter for the PIs.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingEstimateRefsInit( Map_Man_t * p ) -{ - Map_Node_t * pNode; - int i; - for ( i = 0; i < p->vAnds->nSize; i++ ) - { - pNode = p->vAnds->pArray[i]; -// pNode->nRefEst[0] = pNode->nRefEst[1] = ((float)pNode->nRefs)*(float)2.0; - pNode->nRefEst[0] = pNode->nRefEst[1] = pNode->nRefEst[2] = ((float)pNode->nRefs); - } -} - -/**Function************************************************************* - - Synopsis [Sets the estimated reference counter.] - - Description [When this procedure is called for the first time, - the reference counter is estimated from the AIG. Otherwise, it is - a linear combination of reference counters in the last two iterations.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingEstimateRefs( Map_Man_t * p ) -{ - Map_Node_t * pNode; - int i; - for ( i = 0; i < p->vAnds->nSize; i++ ) - { - pNode = p->vAnds->pArray[i]; -// pNode->nRefEst[0] = (float)((2.0 * pNode->nRefEst[0] + 1.0 * pNode->nRefAct[0]) / 3.0); -// pNode->nRefEst[1] = (float)((2.0 * pNode->nRefEst[1] + 1.0 * pNode->nRefAct[1]) / 3.0); -// pNode->nRefEst[2] = (float)((2.0 * pNode->nRefEst[2] + 1.0 * pNode->nRefAct[2]) / 3.0); - pNode->nRefEst[0] = (float)((3.0 * pNode->nRefEst[0] + 1.0 * pNode->nRefAct[0]) / 4.0); - pNode->nRefEst[1] = (float)((3.0 * pNode->nRefEst[1] + 1.0 * pNode->nRefAct[1]) / 4.0); - pNode->nRefEst[2] = (float)((3.0 * pNode->nRefEst[2] + 1.0 * pNode->nRefAct[2]) / 4.0); - } -} - - - - - -/**function************************************************************* - - synopsis [Computes the area flow of the cut.] - - description [Computes the area flow of the cut if it is implemented using - the best supergate with the best phase.] - - sideeffects [] - - seealso [] - -***********************************************************************/ -float Map_CutGetAreaFlow( Map_Cut_t * pCut, int fPhase ) -{ - Map_Match_t * pM = pCut->M + fPhase; - Map_Super_t * pSuper = pM->pSuperBest; - unsigned uPhaseTot = pM->uPhaseBest; - Map_Cut_t * pCutFanin; - float aFlowRes, aFlowFanin, nRefs; - int i, fPinPhasePos; - - // start the resulting area flow - aFlowRes = pSuper->Area; - // iterate through the leaves - for ( i = 0; i < pCut->nLeaves; i++ ) - { - // get the phase of this fanin - fPinPhasePos = ((uPhaseTot & (1 << i)) == 0); - // get the cut implementing this phase of the fanin - pCutFanin = pCut->ppLeaves[i]->pCutBest[fPinPhasePos]; - // if the cut is not available, we have to use the opposite phase - if ( pCutFanin == NULL ) - { - fPinPhasePos = !fPinPhasePos; - pCutFanin = pCut->ppLeaves[i]->pCutBest[fPinPhasePos]; - } - aFlowFanin = pCutFanin->M[fPinPhasePos].AreaFlow; // ignores the area of the interter - // get the fanout count of the cut in the given phase - nRefs = Map_NodeReadRefPhaseEst( pCut->ppLeaves[i], fPinPhasePos ); - // if the node does no fanout, assume fanout count equal to 1 - if ( nRefs == (float)0.0 ) - nRefs = (float)1.0; - // add the area flow due to the fanin - aFlowRes += aFlowFanin / nRefs; - } - pM->AreaFlow = aFlowRes; - return aFlowRes; -} - - - -/**function************************************************************* - - synopsis [Computes the exact area associated with the cut.] - - description [Assumes that the cut is referenced.] - - sideeffects [] - - seealso [] - -***********************************************************************/ -float Map_CutGetAreaRefed( Map_Cut_t * pCut, int fPhase ) -{ - float aResult, aResult2; - aResult2 = Map_CutRefDeref( pCut, fPhase, 0 ); // dereference - aResult = Map_CutRefDeref( pCut, fPhase, 1 ); // reference -// assert( aResult == aResult2 ); - return aResult; -} - -/**function************************************************************* - - synopsis [Computes the exact area associated with the cut.] - - description [] - - sideeffects [] - - seealso [] - -***********************************************************************/ -float Map_CutGetAreaDerefed( Map_Cut_t * pCut, int fPhase ) -{ - float aResult, aResult2; - aResult2 = Map_CutRefDeref( pCut, fPhase, 1 ); // reference - aResult = Map_CutRefDeref( pCut, fPhase, 0 ); // dereference -// assert( aResult == aResult2 ); - return aResult; -} - -/**function************************************************************* - - synopsis [References the cut.] - - description [] - - sideeffects [] - - seealso [] - -***********************************************************************/ -float Map_CutRef( Map_Cut_t * pCut, int fPhase ) -{ - return Map_CutRefDeref( pCut, fPhase, 1 ); // reference -} - -/**function************************************************************* - - synopsis [Dereferences the cut.] - - description [] - - sideeffects [] - - seealso [] - -***********************************************************************/ -float Map_CutDeref( Map_Cut_t * pCut, int fPhase ) -{ - return Map_CutRefDeref( pCut, fPhase, 0 ); // dereference -} - -/**function************************************************************* - - synopsis [References or dereferences the cut.] - - description [This reference part is similar to Cudd_NodeReclaim(). - The dereference part is similar to Cudd_RecursiveDeref().] - - sideeffects [] - - seealso [] - -***********************************************************************/ -float Map_CutRefDeref( Map_Cut_t * pCut, int fPhase, int fReference ) -{ - Map_Node_t * pNodeChild; - Map_Cut_t * pCutChild; - float aArea; - int i, fPhaseChild; -// int nRefs; - - // consider the elementary variable - if ( pCut->nLeaves == 1 ) - return 0; - // start the area of this cut - aArea = Map_CutGetRootArea( pCut, fPhase ); - // go through the children - for ( i = 0; i < pCut->nLeaves; i++ ) - { - pNodeChild = pCut->ppLeaves[i]; - fPhaseChild = Map_CutGetLeafPhase( pCut, fPhase, i ); - // get the reference counter of the child -/* - // this code does not take inverters into account - // the quality of area recovery seems to always be a little worse - if ( fReference ) - nRefs = Map_NodeIncRefPhaseAct( pNodeChild, fPhaseChild ); - else - nRefs = Map_NodeDecRefPhaseAct( pNodeChild, fPhaseChild ); - assert( nRefs >= 0 ); - // skip if the child was already reference before - if ( nRefs > 0 ) - continue; -*/ - - if ( fReference ) - { - if ( pNodeChild->pCutBest[0] && pNodeChild->pCutBest[1] ) // both phases are present - { - // if this phase of the node is referenced, there is no recursive call - pNodeChild->nRefAct[2]++; - if ( pNodeChild->nRefAct[fPhaseChild]++ > 0 ) - continue; - } - else // only one phase is present - { - // inverter should be added if the phase - // (a) has no reference and (b) is implemented using other phase - if ( pNodeChild->nRefAct[fPhaseChild]++ == 0 && pNodeChild->pCutBest[fPhaseChild] == NULL ) - aArea += pNodeChild->p->pSuperLib->AreaInv; - // if the node is referenced, there is no recursive call - if ( pNodeChild->nRefAct[2]++ > 0 ) - continue; - } - } - else - { - if ( pNodeChild->pCutBest[0] && pNodeChild->pCutBest[1] ) // both phases are present - { - // if this phase of the node is referenced, there is no recursive call - --pNodeChild->nRefAct[2]; - if ( --pNodeChild->nRefAct[fPhaseChild] > 0 ) - continue; - } - else // only one phase is present - { - // inverter should be added if the phase - // (a) has no reference and (b) is implemented using other phase - if ( --pNodeChild->nRefAct[fPhaseChild] == 0 && pNodeChild->pCutBest[fPhaseChild] == NULL ) - aArea += pNodeChild->p->pSuperLib->AreaInv; - // if the node is referenced, there is no recursive call - if ( --pNodeChild->nRefAct[2] > 0 ) - continue; - } - assert( pNodeChild->nRefAct[fPhaseChild] >= 0 ); - } - - // get the child cut - pCutChild = pNodeChild->pCutBest[fPhaseChild]; - // if the child does not have this phase mapped, take the opposite phase - if ( pCutChild == NULL ) - { - fPhaseChild = !fPhaseChild; - pCutChild = pNodeChild->pCutBest[fPhaseChild]; - } - // reference and compute area recursively - aArea += Map_CutRefDeref( pCutChild, fPhaseChild, fReference ); - } - return aArea; -} - - - - -/**Function************************************************************* - - Synopsis [Computes actual reference counters.] - - Description [Collects the nodes used in the mapping in array pMan->vMapping. - Nodes are collected in reverse topological order to facilitate the - computation of required times.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingSetRefs( Map_Man_t * pMan ) -{ - Map_Node_t * pNode, ** ppStore; - int i, fPhase, LevelMax; - - // clean all references - for ( i = 0; i < pMan->vNodesAll->nSize; i++ ) - { - pNode = pMan->vNodesAll->pArray[i]; - pNode->nRefAct[0] = 0; - pNode->nRefAct[1] = 0; - pNode->nRefAct[2] = 0; - } - - // find the largest level of a node - LevelMax = 0; - for ( i = 0; i < pMan->nOutputs; i++ ) - if ( LevelMax < (int)Map_Regular(pMan->pOutputs[i])->Level ) - LevelMax = Map_Regular(pMan->pOutputs[i])->Level; - - // allocate place to store the nodes - ppStore = ALLOC( Map_Node_t *, LevelMax + 1 ); - memset( ppStore, 0, sizeof(Map_Node_t *) * (LevelMax + 1) ); - - // visit nodes reachable from POs in the DFS order through the best cuts - for ( i = 0; i < pMan->nOutputs; i++ ) - { - pNode = pMan->pOutputs[i]; - fPhase = !Map_IsComplement(pNode); - if ( !Map_NodeIsConst(pNode) ) - Map_MappingSetRefs_rec( pMan, pNode, ppStore ); - } - - // reconnect the nodes in reverse topological order - pMan->vMapping->nSize = 0; - for ( i = LevelMax; i >= 0; i-- ) - for ( pNode = ppStore[i]; pNode; pNode = (Map_Node_t *)pNode->pData0 ) - Map_NodeVecPush( pMan->vMapping, pNode ); - free( ppStore ); -} - -/**Function************************************************************* - - Synopsis [Recursively computes the DFS ordering of the nodes.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingSetRefs_rec( Map_Man_t * pMan, Map_Node_t * pNode, Map_Node_t ** ppStore ) -{ - Map_Cut_t * pCut; - Map_Node_t * pNodeR; - unsigned uPhase; - int i, fPhase, fInvPin; - - // get the regular node and its phase - pNodeR = Map_Regular(pNode); - fPhase = !Map_IsComplement(pNode); - - // add the node to the list of all visited nodes - if ( pNodeR->nRefAct[2]++ == 0 ) -// Map_NodeVecPush( pMan->vMapping, pNodeR ); - pNodeR->pData0 = (char *)ppStore[pNodeR->Level], ppStore[pNodeR->Level] = pNodeR; - - // quit if the node was already visited in this phase - if ( pNodeR->nRefAct[fPhase]++ ) - return; - - // quit if this is a PI node - if ( Map_NodeIsVar(pNodeR) ) - return; - - // get the cut implementing this or opposite polarity - pCut = pNodeR->pCutBest[fPhase]; - if ( pCut == NULL ) - { - fPhase = !fPhase; - pCut = pNodeR->pCutBest[fPhase]; - } - - // visit the transitive fanin - uPhase = pCut->M[fPhase].uPhaseBest; - for ( i = 0; i < pCut->nLeaves; i++ ) - { - fInvPin = ((uPhase & (1 << i)) > 0); - Map_MappingSetRefs_rec( pMan, Map_NotCond(pCut->ppLeaves[i], fInvPin), ppStore ); - } -} - - -/**Function************************************************************* - - Synopsis [Computes the array of mapping.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -float Map_MappingGetArea( Map_Man_t * pMan, Map_NodeVec_t * vMapping ) -{ - Map_Node_t * pNode; - float Area; - int i; - Area = 0.0; - for ( i = 0; i < vMapping->nSize; i++ ) - { - pNode = vMapping->pArray[i]; - // at least one phase has the best cut assigned - assert( pNode->pCutBest[0] != NULL || pNode->pCutBest[1] != NULL ); - // at least one phase is used in the mapping - assert( pNode->nRefAct[0] > 0 || pNode->nRefAct[1] > 0 ); - // compute the array due to the supergate - if ( Map_NodeIsAnd(pNode) ) - { - // count area of the negative phase - if ( pNode->pCutBest[0] && (pNode->nRefAct[0] > 0 || pNode->pCutBest[1] == NULL) ) - Area += pNode->pCutBest[0]->M[0].pSuperBest->Area; - // count area of the positive phase - if ( pNode->pCutBest[1] && (pNode->nRefAct[1] > 0 || pNode->pCutBest[0] == NULL) ) - Area += pNode->pCutBest[1]->M[1].pSuperBest->Area; - } - // count area of the interver if we need to implement one phase with another phase - if ( (pNode->pCutBest[0] == NULL && pNode->nRefAct[0] > 0) || - (pNode->pCutBest[1] == NULL && pNode->nRefAct[1] > 0) ) - Area += pMan->pSuperLib->AreaInv; - } - // add buffers for each CO driven by a CI - for ( i = 0; i < pMan->nOutputs; i++ ) - if ( Map_NodeIsVar(pMan->pOutputs[i]) && !Map_IsComplement(pMan->pOutputs[i]) ) - Area += pMan->pSuperLib->AreaBuf; - return Area; -} - - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - - diff --git a/src/map/mapper/mapperSuper.c b/src/map/mapper/mapperSuper.c deleted file mode 100644 index ce6a780f..00000000 --- a/src/map/mapper/mapperSuper.c +++ /dev/null @@ -1,449 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapperSuper.c] - - PackageName [MVSIS 1.3: Multi-valued logic synthesis system.] - - Synopsis [Generic technology mapping engine.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 2.0. Started - June 1, 2004.] - - Revision [$Id: mapperSuper.c,v 1.6 2005/01/23 06:59:44 alanmi Exp $] - -***********************************************************************/ - -#include "mapperInt.h" - -//////////////////////////////////////////////////////////////////////// -/// DECLARATIONS /// -//////////////////////////////////////////////////////////////////////// - -static int Map_LibraryReadFile( Map_SuperLib_t * pLib, FILE * pFile ); -static Map_Super_t * Map_LibraryReadGate( Map_SuperLib_t * pLib, char * pBuffer, int nVars ); -static int Map_LibraryTruthVerify( Map_SuperLib_t * pLib, Map_Super_t * pGate ); -static void Map_LibraryComputeTruth( Map_SuperLib_t * pLib, char * pFormula, unsigned uTruthRes[] ); -static void Map_LibraryComputeTruth_rec( Map_SuperLib_t * pLib, char * pFormula, unsigned uTruthsIn[][2], unsigned uTruthRes[] ); -static void Map_LibraryPrintClasses( Map_SuperLib_t * p ); - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**Function************************************************************* - - Synopsis [Reads the supergate library from file.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_LibraryRead( Map_SuperLib_t * pLib, char * pFileName ) -{ - FILE * pFile; - int Status; - // read the beginning of the file - assert( pLib->pGenlib == NULL ); - pFile = fopen( pFileName, "r" ); - if ( pFile == NULL ) - { - printf( "Cannot open input file \"%s\".\n", pFileName ); - return 0; - } - Status = Map_LibraryReadFile( pLib, pFile ); - fclose( pFile ); -// Map_LibraryPrintClasses( pLib ); - return Status; -} - - -/**Function************************************************************* - - Synopsis [Reads the library file.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_LibraryReadFile( Map_SuperLib_t * pLib, FILE * pFile ) -{ - ProgressBar * pProgress; - char pBuffer[2000]; - FILE * pFileGen; - Map_Super_t * pGate; - char * pTemp, * pLibName; - int nCounter, nGatesTotal; - unsigned uCanon[2]; - - // skip empty and comment lines - while ( fgets( pBuffer, 5000, pFile ) != NULL ) - { - // skip leading spaces - for ( pTemp = pBuffer; *pTemp == ' ' || *pTemp == '\r' || *pTemp == '\n'; pTemp++ ); - // skip comment lines and empty lines - if ( *pTemp != 0 && *pTemp != '#' ) - break; - } - - // get the genlib file name - pLibName = strtok( pTemp, " \t\r\n" ); - if ( strcmp( pLibName, "GATE" ) == 0 ) - { - printf( "The input file \"%s\" looks like a GENLIB file and not a supergate library file.\n", pLib->pName ); - return 0; - } - pFileGen = fopen( pLibName, "r" ); - if ( pFileGen == NULL ) - { - printf( "Cannot open the GENLIB file \"%s\".\n", pLibName ); - return 0; - } - fclose( pFileGen ); - - // read the genlib library - pLib->pGenlib = Mio_LibraryRead( Abc_FrameGetGlobalFrame(), pLibName, 0, 0 ); - if ( pLib->pGenlib == NULL ) - { - printf( "Cannot read GENLIB file \"%s\".\n", pLibName ); - return 0; - } - - // read the number of variables - fscanf( pFile, "%d\n", &pLib->nVarsMax ); - if ( pLib->nVarsMax < 2 || pLib->nVarsMax > 10 ) - { - printf( "Suspicious number of variables (%d).\n", pLib->nVarsMax ); - return 0; - } - - // read the number of gates - fscanf( pFile, "%d\n", &nGatesTotal ); - if ( nGatesTotal < 1 || nGatesTotal > 10000000 ) - { - printf( "Suspicious number of gates (%d).\n", nGatesTotal ); - return 0; - } - - // read the lines - nCounter = 0; - pProgress = Extra_ProgressBarStart( stdout, nGatesTotal ); - while ( fgets( pBuffer, 5000, pFile ) != NULL ) - { - for ( pTemp = pBuffer; *pTemp == ' ' || *pTemp == '\r' || *pTemp == '\n'; pTemp++ ); - if ( pTemp[0] == '\0' ) - continue; - // get the gate - pGate = Map_LibraryReadGate( pLib, pTemp, pLib->nVarsMax ); - assert( pGate->Num == nCounter + 1 ); - // count the number of parantheses in the formula - this is the number of gates - for ( pTemp = pGate->pFormula; *pTemp; pTemp++ ) - pGate->nGates += (*pTemp == '('); - // verify the truth table - assert( Map_LibraryTruthVerify(pLib, pGate) ); - - // find the N-canonical form of this supergate - pGate->nPhases = Map_CanonComputeSlow( pLib->uTruths, pLib->nVarsMax, pLib->nVarsMax, pGate->uTruth, pGate->uPhases, uCanon ); - // add the supergate into the table by its N-canonical table - Map_SuperTableInsertC( pLib->tTableC, uCanon, pGate ); - // update the progress bar - Extra_ProgressBarUpdate( pProgress, ++nCounter, NULL ); - } - Extra_ProgressBarStop( pProgress ); - pLib->nSupersAll = nCounter; - if ( nCounter != nGatesTotal ) - printf( "The number of gates read (%d) is different what the file says (%d).\n", nGatesTotal, nCounter ); - return 1; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Super_t * Map_LibraryReadGate( Map_SuperLib_t * pLib, char * pBuffer, int nVars ) -{ - Map_Super_t * pGate; - char * pTemp; - int i; - - // start and clean the gate - pGate = (Map_Super_t *)Extra_MmFixedEntryFetch( pLib->mmSupers ); - memset( pGate, 0, sizeof(Map_Super_t) ); - - // read the number - pTemp = strtok( pBuffer, " " ); - pGate->Num = atoi(pTemp); - - // read the signature - pTemp = strtok( NULL, " " ); - if ( pLib->nVarsMax < 6 ) - { - pGate->uTruth[0] = Extra_ReadBinary(pTemp); - pGate->uTruth[1] = 0; - } - else - { - pGate->uTruth[0] = Extra_ReadBinary(pTemp+32); - pTemp[32] = 0; - pGate->uTruth[1] = Extra_ReadBinary(pTemp); - } - - // read the max delay - pTemp = strtok( NULL, " " ); - pGate->tDelayMax.Rise = (float)atof(pTemp); - pGate->tDelayMax.Fall = pGate->tDelayMax.Rise; - - // read the pin-to-pin delay - for ( i = 0; i < nVars; i++ ) - { - pTemp = strtok( NULL, " " ); - pGate->tDelaysR[i].Rise = (float)atof(pTemp); - pGate->tDelaysF[i].Fall = pGate->tDelaysR[i].Rise; - } - - // read the area - pTemp = strtok( NULL, " " ); - pGate->Area = (float)atof(pTemp); - - // the rest is the gate name - pTemp = strtok( NULL, " \r\n" ); - if ( strlen(pTemp) == 0 ) - printf( "A gate name is empty.\n" ); - - // save the gate name - pGate->pFormula = Extra_MmFlexEntryFetch( pLib->mmForms, strlen(pTemp) + 1 ); - strcpy( pGate->pFormula, pTemp ); - - // the rest is the gate name - pTemp = strtok( NULL, " \n\0" ); - if ( pTemp != NULL ) - printf( "The following trailing symbols found \"%s\".\n", pTemp ); - return pGate; -} - -/**Function************************************************************* - - Synopsis [Performs one step of parsing the formula into parts.] - - Description [This function will eventually be replaced when the - tree-supergate library representation will become standard.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -char * Map_LibraryReadFormulaStep( char * pFormula, char * pStrings[], int * pnStrings ) -{ - char * pName, * pPar1, * pPar2, * pCur; - int nStrings, CountPars; - - // skip leading spaces - for ( pName = pFormula; *pName && *pName == ' '; pName++ ); - assert( *pName ); - // find the first opening paranthesis - for ( pPar1 = pName; *pPar1 && *pPar1 != '('; pPar1++ ); - if ( *pPar1 == 0 ) - { - *pnStrings = 0; - return pName; - } - // overwrite it with space - assert( *pPar1 == '(' ); - *pPar1 = 0; - // find the corresponding closing paranthesis - for ( CountPars = 1, pPar2 = pPar1 + 1; *pPar2 && CountPars; pPar2++ ) - if ( *pPar2 == '(' ) - CountPars++; - else if ( *pPar2 == ')' ) - CountPars--; - pPar2--; - assert( CountPars == 0 ); - // overwrite it with space - assert( *pPar2 == ')' ); - *pPar2 = 0; - // save the intervals between the commas - nStrings = 0; - pCur = pPar1 + 1; - while ( 1 ) - { - // save the current string - pStrings[ nStrings++ ] = pCur; - // find the beginning of the next string - for ( CountPars = 0; *pCur && (CountPars || *pCur != ','); pCur++ ) - if ( *pCur == '(' ) - CountPars++; - else if ( *pCur == ')' ) - CountPars--; - if ( *pCur == 0 ) - break; - assert( *pCur == ',' ); - *pCur = 0; - pCur++; - } - // save the results and return - *pnStrings = nStrings; - return pName; -} - - -/**Function************************************************************* - - Synopsis [Verifies the truth table of the supergate.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_LibraryTruthVerify( Map_SuperLib_t * pLib, Map_Super_t * pGate ) -{ - unsigned uTruthRes[2]; - Map_LibraryComputeTruth( pLib, pGate->pFormula, uTruthRes ); - if ( uTruthRes[0] != pGate->uTruth[0] || uTruthRes[1] != pGate->uTruth[1] ) - return 0; - return 1; -} - - -/**Function************************************************************* - - Synopsis [Derives the functionality of the supergate.] - - Description [This procedure is useful for verification the supergate - library. The truth table derived by this procedure should be the same - as the one contained in the original supergate file.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_LibraryComputeTruth( Map_SuperLib_t * pLib, char * pFormula, unsigned uTruthRes[] ) -{ - char Buffer[1000]; - strcpy( Buffer, pFormula ); - Map_LibraryComputeTruth_rec( pLib, Buffer, pLib->uTruths, uTruthRes ); -} - -/**Function************************************************************* - - Synopsis [Derives the functionality of the supergate.] - - Description [This procedure is useful for verification the supergate - library. The truth table derived by this procedure should be the same - as the one contained in the original supergate file.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_LibraryComputeTruth_rec( Map_SuperLib_t * pLib, char * pFormula, unsigned uTruthsIn[][2], unsigned uTruthRes[] ) -{ - Mio_Gate_t * pMioGate; - char * pGateName, * pStrings[6]; - unsigned uTruthsFanins[6][2]; - int nStrings, i; - - // perform one step parsing of the formula - // detect the root gate name, the next-step strings, and their number - pGateName = Map_LibraryReadFormulaStep( pFormula, pStrings, &nStrings ); - if ( nStrings == 0 ) // elementary variable - { - assert( pGateName[0] - 'a' < pLib->nVarsMax ); - uTruthRes[0] = uTruthsIn[pGateName[0] - 'a'][0]; - uTruthRes[1] = uTruthsIn[pGateName[0] - 'a'][1]; - return; - } - // derive the functionality of the fanins - for ( i = 0; i < nStrings; i++ ) - Map_LibraryComputeTruth_rec( pLib, pStrings[i], uTruthsIn, uTruthsFanins[i] ); - // get the root supergate - pMioGate = Mio_LibraryReadGateByName( pLib->pGenlib, pGateName ); - if ( pMioGate == NULL ) - printf( "A supergate contains gate \"%s\" that is not in \"%s\".\n", pGateName, Mio_LibraryReadName(pLib->pGenlib) ); - // derive the functionality of the output of the supergate - Mio_DeriveTruthTable( pMioGate, uTruthsFanins, nStrings, pLib->nVarsMax, uTruthRes ); -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_LibraryPrintSupergate( Map_Super_t * pGate ) -{ - printf( "%5d : ", pGate->nUsed ); - printf( "%5d ", pGate->Num ); - printf( "A = %5.2f ", pGate->Area ); - printf( "D = %5.2f ", pGate->tDelayMax ); - printf( "%s", pGate->pFormula ); - printf( "\n" ); -} - - -/**Function************************************************************* - - Synopsis [Prints N-classes of supergates.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_LibraryPrintClasses( Map_SuperLib_t * p ) -{ -/* - st_generator * gen; - Map_Super_t * pSuper, * pSuper2; - unsigned Key, uTruth; - int Counter = 0; - // copy all the supergates into one array - st_foreach_item( p->tSuplib, gen, (char **)&Key, (char **)&pSuper ) - { - for ( pSuper2 = pSuper; pSuper2; pSuper2 = pSuper2->pNext ) - { - uTruth = pSuper2->Phase; - Extra_PrintBinary( stdout, &uTruth, 5 ); - printf( " %5d ", pSuper2->Num ); - printf( "%s", pSuper2->pFormula ); - printf( "\n" ); - } - printf( "\n" ); - if ( ++ Counter == 100 ) - break; - } -*/ -} - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - - diff --git a/src/map/mapper/mapperSwitch.c b/src/map/mapper/mapperSwitch.c deleted file mode 100644 index 9dd6e42b..00000000 --- a/src/map/mapper/mapperSwitch.c +++ /dev/null @@ -1,223 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapperSwitch.c] - - PackageName [MVSIS 1.3: Multi-valued logic synthesis system.] - - Synopsis [Generic technology mapping engine.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 1.0. Started - September 8, 2003.] - - Revision [$Id: mapperSwitch.h,v 1.0 2003/09/08 00:00:00 alanmi Exp $] - -***********************************************************************/ - -#include "mapperInt.h" - -//////////////////////////////////////////////////////////////////////// -/// DECLARATIONS /// -//////////////////////////////////////////////////////////////////////// - -static float Map_SwitchCutRefDeref( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase, int fReference ); - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**function************************************************************* - - synopsis [Computes the exact area associated with the cut.] - - description [] - - sideeffects [] - - seealso [] - -***********************************************************************/ -float Map_SwitchCutGetDerefed( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase ) -{ - float aResult, aResult2; -// assert( pNode->Switching > 0 ); - aResult2 = Map_SwitchCutRefDeref( pNode, pCut, fPhase, 1 ); // reference - aResult = Map_SwitchCutRefDeref( pNode, pCut, fPhase, 0 ); // dereference -// assert( aResult == aResult2 ); - return aResult; -} - -/**function************************************************************* - - synopsis [References the cut.] - - description [] - - sideeffects [] - - seealso [] - -***********************************************************************/ -float Map_SwitchCutRef( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase ) -{ - return Map_SwitchCutRefDeref( pNode, pCut, fPhase, 1 ); // reference -} - -/**function************************************************************* - - synopsis [References the cut.] - - description [] - - sideeffects [] - - seealso [] - -***********************************************************************/ -float Map_SwitchCutDeref( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase ) -{ - return Map_SwitchCutRefDeref( pNode, pCut, fPhase, 0 ); // dereference -} - -/**function************************************************************* - - synopsis [References or dereferences the cut.] - - description [This reference part is similar to Cudd_NodeReclaim(). - The dereference part is similar to Cudd_RecursiveDeref().] - - sideeffects [] - - seealso [] - -***********************************************************************/ -float Map_SwitchCutRefDeref( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase, int fReference ) -{ - Map_Node_t * pNodeChild; - Map_Cut_t * pCutChild; - float aSwitchActivity; - int i, fPhaseChild; - - // start switching activity for the node - aSwitchActivity = pNode->Switching; - // consider the elementary variable - if ( pCut->nLeaves == 1 ) - return aSwitchActivity; - - // go through the children - assert( pCut->M[fPhase].pSuperBest ); - for ( i = 0; i < pCut->nLeaves; i++ ) - { - pNodeChild = pCut->ppLeaves[i]; - fPhaseChild = Map_CutGetLeafPhase( pCut, fPhase, i ); - // get the reference counter of the child - - if ( fReference ) - { - if ( pNodeChild->pCutBest[0] && pNodeChild->pCutBest[1] ) // both phases are present - { - // if this phase of the node is referenced, there is no recursive call - pNodeChild->nRefAct[2]++; - if ( pNodeChild->nRefAct[fPhaseChild]++ > 0 ) - continue; - } - else // only one phase is present - { - // inverter should be added if the phase - // (a) has no reference and (b) is implemented using other phase - if ( pNodeChild->nRefAct[fPhaseChild]++ == 0 && pNodeChild->pCutBest[fPhaseChild] == NULL ) - aSwitchActivity += pNodeChild->Switching; // inverter switches the same as the node - // if the node is referenced, there is no recursive call - if ( pNodeChild->nRefAct[2]++ > 0 ) - continue; - } - } - else - { - if ( pNodeChild->pCutBest[0] && pNodeChild->pCutBest[1] ) // both phases are present - { - // if this phase of the node is referenced, there is no recursive call - --pNodeChild->nRefAct[2]; - if ( --pNodeChild->nRefAct[fPhaseChild] > 0 ) - continue; - } - else // only one phase is present - { - // inverter should be added if the phase - // (a) has no reference and (b) is implemented using other phase - if ( --pNodeChild->nRefAct[fPhaseChild] == 0 && pNodeChild->pCutBest[fPhaseChild] == NULL ) - aSwitchActivity += pNodeChild->Switching; // inverter switches the same as the node - // if the node is referenced, there is no recursive call - if ( --pNodeChild->nRefAct[2] > 0 ) - continue; - } - assert( pNodeChild->nRefAct[fPhaseChild] >= 0 ); - } - - // get the child cut - pCutChild = pNodeChild->pCutBest[fPhaseChild]; - // if the child does not have this phase mapped, take the opposite phase - if ( pCutChild == NULL ) - { - fPhaseChild = !fPhaseChild; - pCutChild = pNodeChild->pCutBest[fPhaseChild]; - } - // reference and compute area recursively - aSwitchActivity += Map_SwitchCutRefDeref( pNodeChild, pCutChild, fPhaseChild, fReference ); - } - return aSwitchActivity; -} - -/**Function************************************************************* - - Synopsis [Computes the array of mapping.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -float Map_MappingGetSwitching( Map_Man_t * pMan, Map_NodeVec_t * vMapping ) -{ - Map_Node_t * pNode; - float Switch; - int i; - Switch = 0.0; - for ( i = 0; i < vMapping->nSize; i++ ) - { - pNode = vMapping->pArray[i]; - // at least one phase has the best cut assigned - assert( pNode->pCutBest[0] != NULL || pNode->pCutBest[1] != NULL ); - // at least one phase is used in the mapping - assert( pNode->nRefAct[0] > 0 || pNode->nRefAct[1] > 0 ); - // compute the array due to the supergate - if ( Map_NodeIsAnd(pNode) ) - { - // count switching of the negative phase - if ( pNode->pCutBest[0] && (pNode->nRefAct[0] > 0 || pNode->pCutBest[1] == NULL) ) - Switch += pNode->Switching; - // count switching of the positive phase - if ( pNode->pCutBest[1] && (pNode->nRefAct[1] > 0 || pNode->pCutBest[0] == NULL) ) - Switch += pNode->Switching; - } - // count switching of the interver if we need to implement one phase with another phase - if ( (pNode->pCutBest[0] == NULL && pNode->nRefAct[0] > 0) || - (pNode->pCutBest[1] == NULL && pNode->nRefAct[1] > 0) ) - Switch += pNode->Switching; // inverter switches the same as the node - } - // add buffers for each CO driven by a CI - for ( i = 0; i < pMan->nOutputs; i++ ) - if ( Map_NodeIsVar(pMan->pOutputs[i]) && !Map_IsComplement(pMan->pOutputs[i]) ) - Switch += pMan->pOutputs[i]->Switching; - return Switch; -} - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - - diff --git a/src/map/mapper/mapperTable.c b/src/map/mapper/mapperTable.c deleted file mode 100644 index d0cb7a01..00000000 --- a/src/map/mapper/mapperTable.c +++ /dev/null @@ -1,402 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapperTable.c] - - PackageName [MVSIS 1.3: Multi-valued logic synthesis system.] - - Synopsis [Generic technology mapping engine.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 2.0. Started - June 1, 2004.] - - Revision [$Id: mapperTable.c,v 1.6 2005/01/23 06:59:44 alanmi Exp $] - -***********************************************************************/ - -#include "mapperInt.h" - -//////////////////////////////////////////////////////////////////////// -/// DECLARATIONS /// -//////////////////////////////////////////////////////////////////////// - -// the table function for the tables -#define MAP_TABLE_HASH(u1,u2,nSize) (((u1) + 2003 * (u2)) % nSize) - -static void Map_SuperTableResize( Map_HashTable_t * pLib ); - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**Function************************************************************* - - Synopsis [Creates the hash table for supergates.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_HashTable_t * Map_SuperTableCreate( Map_SuperLib_t * pLib ) -{ - Map_HashTable_t * p; - // allocate the table - p = ALLOC( Map_HashTable_t, 1 ); - memset( p, 0, sizeof(Map_HashTable_t) ); - p->mmMan = pLib->mmEntries; - // allocate and clean the bins - p->nBins = Cudd_Prime(20000); - p->pBins = ALLOC( Map_HashEntry_t *, p->nBins ); - memset( p->pBins, 0, sizeof(Map_HashEntry_t *) * p->nBins ); - return p; -} - - -/**Function************************************************************* - - Synopsis [Deallocates the supergate hash table.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_SuperTableFree( Map_HashTable_t * p ) -{ - FREE( p->pBins ); - FREE( p ); -} - -/**Function************************************************************* - - Synopsis [Inserts a new entry into the hash table.] - - Description [This function inserts the new gate (pGate), which will be - accessible through its canonical form (uTruthC).] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_SuperTableInsertC( Map_HashTable_t * p, unsigned uTruthC[], Map_Super_t * pGate ) -{ - Map_HashEntry_t * pEnt; - unsigned Key; - // resize the table - if ( p->nEntries >= 2 * p->nBins ) - Map_SuperTableResize( p ); - // check if another supergate with the same canonical form exists - Key = MAP_TABLE_HASH( uTruthC[0], uTruthC[1], p->nBins ); - for ( pEnt = p->pBins[Key]; pEnt; pEnt = pEnt->pNext ) - if ( pEnt->uTruth[0] == uTruthC[0] && pEnt->uTruth[1] == uTruthC[1] ) - break; - // create a new entry if it does not exist - if ( pEnt == NULL ) - { - // add the new entry to the table - pEnt = (Map_HashEntry_t *)Extra_MmFixedEntryFetch( p->mmMan ); - memset( pEnt, 0, sizeof(Map_HashEntry_t) ); - pEnt->uTruth[0] = uTruthC[0]; - pEnt->uTruth[1] = uTruthC[1]; - // add the hash table entry to the corresponding linked list in the table - pEnt->pNext = p->pBins[Key]; - p->pBins[Key] = pEnt; - p->nEntries++; - } - // add the supergate to the entry - pGate->pNext = pEnt->pGates; - pEnt->pGates = pGate; - return 0; -} - - - -/**Function************************************************************* - - Synopsis [Inserts a new entry into the library.] - - Description [This function inserts the new gate (pGate), which will be - accessible through its unfolded function (uTruth).] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_SuperTableInsert( Map_HashTable_t * p, unsigned uTruth[], Map_Super_t * pGate, unsigned uPhase ) -{ - Map_HashEntry_t * pEnt; - unsigned Key; - // resize the table - if ( p->nEntries >= 2 * p->nBins ) - Map_SuperTableResize( p ); - // check if this entry already exists - Key = MAP_TABLE_HASH( uTruth[0], uTruth[1], p->nBins ); - for ( pEnt = p->pBins[Key]; pEnt; pEnt = pEnt->pNext ) - if ( pEnt->uTruth[0] == uTruth[0] && pEnt->uTruth[1] == uTruth[1] ) - return 1; - // add the new hash table entry to the table - pEnt = (Map_HashEntry_t *)Extra_MmFixedEntryFetch( p->mmMan ); - memset( pEnt, 0, sizeof(Map_HashEntry_t) ); - pEnt->uTruth[0] = uTruth[0]; - pEnt->uTruth[1] = uTruth[1]; - pEnt->pGates = pGate; - pEnt->uPhase = uPhase; - // add the hash table to the corresponding linked list in the table - pEnt->pNext = p->pBins[Key]; - p->pBins[Key] = pEnt; - p->nEntries++; -/* -printf( "Adding gate: %10u ", Key ); -Map_LibraryPrintSupergate( pGate ); -Extra_PrintBinary( stdout, uTruth, 32 ); -printf( "\n" ); -*/ - return 0; -} - -/**Function************************************************************* - - Synopsis [Looks up an entry in the library.] - - Description [This function looks up the function, given by its truth table, - and return two things: (1) the linked list of supergates, which can implement - the functions of this N-class; (2) the phase, which should be applied to the - given function, in order to derive the canonical form of this N-class.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Super_t * Map_SuperTableLookupC( Map_SuperLib_t * p, unsigned uTruth[] ) -{ - Map_HashEntry_t * pEnt; - unsigned Key; - Key = MAP_TABLE_HASH( uTruth[0], uTruth[1], p->tTableC->nBins ); - for ( pEnt = p->tTableC->pBins[Key]; pEnt; pEnt = pEnt->pNext ) - if ( pEnt->uTruth[0] == uTruth[0] && pEnt->uTruth[1] == uTruth[1] ) - return pEnt->pGates; - return NULL; -} - -/**Function************************************************************* - - Synopsis [Looks up an entry in the library.] - - Description [This function looks up the function, given by its truth table, - and return two things: (1) the linked list of supergates, which can implement - the functions of this N-class; (2) the phase, which should be applied to the - given function, in order to derive the canonical form of this N-class.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Super_t * Map_SuperTableLookup( Map_HashTable_t * p, unsigned uTruth[], unsigned * puPhase ) -{ - Map_HashEntry_t * pEnt; - unsigned Key; - Key = MAP_TABLE_HASH( uTruth[0], uTruth[1], p->nBins ); - for ( pEnt = p->pBins[Key]; pEnt; pEnt = pEnt->pNext ) - if ( pEnt->uTruth[0] == uTruth[0] && pEnt->uTruth[1] == uTruth[1] ) - { - *puPhase = pEnt->uPhase; - return pEnt->pGates; - } - return NULL; -} - -/**Function************************************************************* - - Synopsis [Resizes the table.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_SuperTableResize( Map_HashTable_t * p ) -{ - Map_HashEntry_t ** pBinsNew; - Map_HashEntry_t * pEnt, * pEnt2; - int nBinsNew, Counter, i, clk = clock(); - unsigned Key; - // get the new table size - nBinsNew = Cudd_Prime(2 * p->nBins); - // allocate a new array - pBinsNew = ALLOC( Map_HashEntry_t *, nBinsNew ); - memset( pBinsNew, 0, sizeof(Map_HashEntry_t *) * nBinsNew ); - // rehash the entries from the old table - Counter = 0; - for ( i = 0; i < p->nBins; i++ ) - for ( pEnt = p->pBins[i], pEnt2 = pEnt? pEnt->pNext: NULL; pEnt; - pEnt = pEnt2, pEnt2 = pEnt? pEnt->pNext: NULL ) - { - Key = MAP_TABLE_HASH( pEnt->uTruth[0], pEnt->uTruth[1], nBinsNew ); - pEnt->pNext = pBinsNew[Key]; - pBinsNew[Key] = pEnt; - Counter++; - } - assert( Counter == p->nEntries ); - // replace the table and the parameters - free( p->pBins ); - p->pBins = pBinsNew; - p->nBins = nBinsNew; -} - -/**Function************************************************************* - - Synopsis [Compares the supergates by the number of times they are used.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_SuperTableCompareSupergates( Map_Super_t ** ppS1, Map_Super_t ** ppS2 ) -{ - if ( (*ppS1)->nUsed > (*ppS2)->nUsed ) - return -1; - if ( (*ppS1)->nUsed < (*ppS2)->nUsed ) - return 1; - return 0; -} - -/**Function************************************************************* - - Synopsis [Compares the supergates by the number of times they are used.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_SuperTableCompareGatesInList( Map_Super_t ** ppS1, Map_Super_t ** ppS2 ) -{ -// if ( (*ppS1)->tDelayMax.Rise > (*ppS2)->tDelayMax.Rise ) - if ( (*ppS1)->Area > (*ppS2)->Area ) - return -1; -// if ( (*ppS1)->tDelayMax.Rise < (*ppS2)->tDelayMax.Rise ) - if ( (*ppS1)->Area < (*ppS2)->Area ) - return 1; - return 0; -} - -/**Function************************************************************* - - Synopsis [Sorts supergates by usefulness and prints out most useful.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_SuperTableSortSupergates( Map_HashTable_t * p, int nSupersMax ) -{ - Map_HashEntry_t * pEnt; - Map_Super_t ** ppSupers; - Map_Super_t * pSuper; - int nSupers, i; - - // copy all the supergates into one array - ppSupers = ALLOC( Map_Super_t *, nSupersMax ); - nSupers = 0; - for ( i = 0; i < p->nBins; i++ ) - for ( pEnt = p->pBins[i]; pEnt; pEnt = pEnt->pNext ) - for ( pSuper = pEnt->pGates; pSuper; pSuper = pSuper->pNext ) - ppSupers[nSupers++] = pSuper; - - // sort by usage - qsort( (void *)ppSupers, nSupers, sizeof(Map_Super_t *), - (int (*)(const void *, const void *)) Map_SuperTableCompareSupergates ); - assert( Map_SuperTableCompareSupergates( ppSupers, ppSupers + nSupers - 1 ) <= 0 ); - - // print out the "top ten" -// for ( i = 0; i < nSupers; i++ ) - for ( i = 0; i < 10; i++ ) - { - if ( ppSupers[i]->nUsed == 0 ) - break; - printf( "%5d : ", ppSupers[i]->nUsed ); - printf( "%5d ", ppSupers[i]->Num ); - printf( "A = %5.2f ", ppSupers[i]->Area ); - printf( "D = %5.2f ", ppSupers[i]->tDelayMax.Rise ); - printf( "%s", ppSupers[i]->pFormula ); - printf( "\n" ); - } - free( ppSupers ); -} - -/**Function************************************************************* - - Synopsis [Sorts supergates by max delay for each truth table.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_SuperTableSortSupergatesByDelay( Map_HashTable_t * p, int nSupersMax ) -{ - Map_HashEntry_t * pEnt; - Map_Super_t ** ppSupers; - Map_Super_t * pSuper; - int nSupers, i, k; - - ppSupers = ALLOC( Map_Super_t *, nSupersMax ); - for ( i = 0; i < p->nBins; i++ ) - for ( pEnt = p->pBins[i]; pEnt; pEnt = pEnt->pNext ) - { - // collect the gates in this entry - nSupers = 0; - for ( pSuper = pEnt->pGates; pSuper; pSuper = pSuper->pNext ) - { - // skip supergates, whose root is the AND gate -// if ( strcmp( Mio_GateReadName(pSuper->pRoot), "and" ) == 0 ) -// continue; - ppSupers[nSupers++] = pSuper; - } - pEnt->pGates = NULL; - if ( nSupers == 0 ) - continue; - // sort the gates by delay - qsort( (void *)ppSupers, nSupers, sizeof(Map_Super_t *), - (int (*)(const void *, const void *)) Map_SuperTableCompareGatesInList ); - assert( Map_SuperTableCompareGatesInList( ppSupers, ppSupers + nSupers - 1 ) <= 0 ); - // link them in the reverse order - for ( k = 0; k < nSupers; k++ ) - { - ppSupers[k]->pNext = pEnt->pGates; - pEnt->pGates = ppSupers[k]; - } - // save the number of supergates in the list - pEnt->pGates->nSupers = nSupers; - } - FREE( ppSupers ); -} - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - - diff --git a/src/map/mapper/mapperTime.c b/src/map/mapper/mapperTime.c deleted file mode 100644 index cc4173cf..00000000 --- a/src/map/mapper/mapperTime.c +++ /dev/null @@ -1,510 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapperTime.c] - - PackageName [MVSIS 1.3: Multi-valued logic synthesis system.] - - Synopsis [Generic technology mapping engine.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 2.0. Started - June 1, 2004.] - - Revision [$Id: mapperTime.c,v 1.3 2005/03/02 02:35:54 alanmi Exp $] - -***********************************************************************/ - -#include "mapperInt.h" - -//////////////////////////////////////////////////////////////////////// -/// DECLARATIONS /// -//////////////////////////////////////////////////////////////////////// - -static void Map_TimePropagateRequired( Map_Man_t * p, Map_NodeVec_t * vNodes ); -static void Map_TimePropagateRequiredPhase( Map_Man_t * p, Map_Node_t * pNode, int fPhase ); -static float Map_MatchComputeReqTimes( Map_Cut_t * pCut, int fPhase, Map_Time_t * ptArrRes ); - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**function************************************************************* - - synopsis [Computes the exact area associated with the cut.] - - description [] - - sideeffects [] - - seealso [] - -***********************************************************************/ -float Map_TimeMatchWithInverter( Map_Man_t * p, Map_Match_t * pMatch ) -{ - Map_Time_t tArrInv; - tArrInv.Fall = pMatch->tArrive.Rise + p->pSuperLib->tDelayInv.Fall; - tArrInv.Rise = pMatch->tArrive.Fall + p->pSuperLib->tDelayInv.Rise; - tArrInv.Worst = MAP_MAX( tArrInv.Rise, tArrInv.Fall ); - return tArrInv.Worst; -} - -/**Function************************************************************* - - Synopsis [Computes the arrival times of the cut recursively.] - - Description [When computing the arrival time for the previously unused - cuts, their arrival time may be incorrect because their fanins have - incorrect arrival time. This procedure is called to fix this problem.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_TimeCutComputeArrival_rec( Map_Cut_t * pCut, int fPhase ) -{ - int i, fPhaseLeaf; - for ( i = 0; i < pCut->nLeaves; i++ ) - { - fPhaseLeaf = Map_CutGetLeafPhase( pCut, fPhase, i ); - if ( pCut->ppLeaves[i]->nRefAct[fPhaseLeaf] > 0 ) - continue; - Map_TimeCutComputeArrival_rec( pCut->ppLeaves[i]->pCutBest[fPhaseLeaf], fPhaseLeaf ); - } - Map_TimeCutComputeArrival( NULL, pCut, fPhase, MAP_FLOAT_LARGE ); -} - -/**Function************************************************************* - - Synopsis [Computes the arrival times of the cut.] - - Description [Computes the arrival times of the cut if it is implemented using - the given supergate with the given phase. Uses the constraint-type specification - of rise/fall arrival times.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -float Map_TimeCutComputeArrival( Map_Node_t * pNode, Map_Cut_t * pCut, int fPhase, float tWorstLimit ) -{ - Map_Match_t * pM = pCut->M + fPhase; - Map_Super_t * pSuper = pM->pSuperBest; - unsigned uPhaseTot = pM->uPhaseBest; - Map_Time_t * ptArrRes = &pM->tArrive; - Map_Time_t * ptArrIn; - bool fPinPhase; - float tDelay; - int i; - - ptArrRes->Rise = ptArrRes->Fall = 0.0; - ptArrRes->Worst = MAP_FLOAT_LARGE; - for ( i = pCut->nLeaves - 1; i >= 0; i-- ) - { - // get the phase of the given pin - fPinPhase = ((uPhaseTot & (1 << i)) == 0); - ptArrIn = pCut->ppLeaves[i]->tArrival + fPinPhase; - - // get the rise of the output due to rise of the inputs - if ( pSuper->tDelaysR[i].Rise > 0 ) - { - tDelay = ptArrIn->Rise + pSuper->tDelaysR[i].Rise; - if ( tDelay > tWorstLimit ) - return MAP_FLOAT_LARGE; - if ( ptArrRes->Rise < tDelay ) - ptArrRes->Rise = tDelay; - } - - // get the rise of the output due to fall of the inputs - if ( pSuper->tDelaysR[i].Fall > 0 ) - { - tDelay = ptArrIn->Fall + pSuper->tDelaysR[i].Fall; - if ( tDelay > tWorstLimit ) - return MAP_FLOAT_LARGE; - if ( ptArrRes->Rise < tDelay ) - ptArrRes->Rise = tDelay; - } - - // get the fall of the output due to rise of the inputs - if ( pSuper->tDelaysF[i].Rise > 0 ) - { - tDelay = ptArrIn->Rise + pSuper->tDelaysF[i].Rise; - if ( tDelay > tWorstLimit ) - return MAP_FLOAT_LARGE; - if ( ptArrRes->Fall < tDelay ) - ptArrRes->Fall = tDelay; - } - - // get the fall of the output due to fall of the inputs - if ( pSuper->tDelaysF[i].Fall > 0 ) - { - tDelay = ptArrIn->Fall + pSuper->tDelaysF[i].Fall; - if ( tDelay > tWorstLimit ) - return MAP_FLOAT_LARGE; - if ( ptArrRes->Fall < tDelay ) - ptArrRes->Fall = tDelay; - } - } - // return the worst-case of rise/fall arrival times - ptArrRes->Worst = MAP_MAX(ptArrRes->Rise, ptArrRes->Fall); - return ptArrRes->Worst; -} - - -/**Function************************************************************* - - Synopsis [Computes the maximum arrival times.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -float Map_TimeComputeArrivalMax( Map_Man_t * p ) -{ - float tReqMax, tReq; - int i, fPhase; - // get the critical PO arrival time - tReqMax = -MAP_FLOAT_LARGE; - for ( i = 0; i < p->nOutputs; i++ ) - { - if ( Map_NodeIsConst(p->pOutputs[i]) ) - continue; - fPhase = !Map_IsComplement(p->pOutputs[i]); - tReq = Map_Regular(p->pOutputs[i])->tArrival[fPhase].Worst; - tReqMax = MAP_MAX( tReqMax, tReq ); - } - return tReqMax; -} - -/**Function************************************************************* - - Synopsis [Computes the required times of all nodes.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_TimeComputeRequiredGlobal( Map_Man_t * p ) -{ - p->fRequiredGlo = Map_TimeComputeArrivalMax( p ); - // update the required times according to the target - if ( p->DelayTarget != -1 ) - { - if ( p->fRequiredGlo > p->DelayTarget + p->fEpsilon ) - { - if ( p->fMappingMode == 1 ) - printf( "Cannot meet the target required times (%4.2f). Continue anyway.\n", p->DelayTarget ); - } - else if ( p->fRequiredGlo < p->DelayTarget - p->fEpsilon ) - { - if ( p->fMappingMode == 1 ) - printf( "Relaxing the required times from (%4.2f) to the target (%4.2f).\n", p->fRequiredGlo, p->DelayTarget ); - p->fRequiredGlo = p->DelayTarget; - } - } - Map_TimeComputeRequired( p, p->fRequiredGlo ); -} - -/**Function************************************************************* - - Synopsis [Computes the required times of all nodes.] - - Description [This procedure assumes that the nodes used in the mapping - are collected in p->vMapping.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_TimeComputeRequired( Map_Man_t * p, float fRequired ) -{ - Map_Time_t * ptTime; - int fPhase, i; - - // clean the required times - for ( i = 0; i < p->vAnds->nSize; i++ ) - { - p->vAnds->pArray[i]->tRequired[0].Rise = MAP_FLOAT_LARGE; - p->vAnds->pArray[i]->tRequired[0].Fall = MAP_FLOAT_LARGE; - p->vAnds->pArray[i]->tRequired[0].Worst = MAP_FLOAT_LARGE; - p->vAnds->pArray[i]->tRequired[1].Rise = MAP_FLOAT_LARGE; - p->vAnds->pArray[i]->tRequired[1].Fall = MAP_FLOAT_LARGE; - p->vAnds->pArray[i]->tRequired[1].Worst = MAP_FLOAT_LARGE; - } - - // set the required times for the POs - for ( i = 0; i < p->nOutputs; i++ ) - { - fPhase = !Map_IsComplement(p->pOutputs[i]); - ptTime = Map_Regular(p->pOutputs[i])->tRequired + fPhase; - ptTime->Rise = ptTime->Fall = ptTime->Worst = fRequired; - } - - // sorts the nodes in the decreasing order of levels - // this puts the nodes in reverse topological order -// Map_MappingSortByLevel( p, p->vMapping ); - // the array is already sorted by construction in Map_MappingSetRefs() - - Map_TimePropagateRequired( p, p->vMapping ); -} - -/**Function************************************************************* - - Synopsis [Computes the required times of the given nodes.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_TimePropagateRequired( Map_Man_t * p, Map_NodeVec_t * vNodes ) -{ - Map_Node_t * pNode; - Map_Time_t tReqOutTest, * ptReqOutTest = &tReqOutTest; - Map_Time_t * ptReqIn, * ptReqOut; - int fPhase, k; - - // go through the nodes in the reverse topological order - for ( k = 0; k < vNodes->nSize; k++ ) - { - pNode = vNodes->pArray[k]; - - // this computation works for regular nodes only - assert( !Map_IsComplement(pNode) ); - // at least one phase should be mapped - assert( pNode->pCutBest[0] != NULL || pNode->pCutBest[1] != NULL ); - // the node should be used in the currently assigned mapping - assert( pNode->nRefAct[0] > 0 || pNode->nRefAct[1] > 0 ); - - // if one of the cuts is not given, project the required times from the other cut - if ( pNode->pCutBest[0] == NULL || pNode->pCutBest[1] == NULL ) - { -// assert( 0 ); - // get the missing phase - fPhase = (pNode->pCutBest[1] == NULL); - // check if the missing phase is needed in the mapping - if ( pNode->nRefAct[fPhase] > 0 ) - { - // get the pointers to the required times of the missing phase - ptReqOut = pNode->tRequired + fPhase; -// assert( ptReqOut->Fall < MAP_FLOAT_LARGE ); - // get the pointers to the required times of the present phase - ptReqIn = pNode->tRequired + !fPhase; - // propagate the required times from the missing phase to the present phase - // tArrInv.Fall = pMatch->tArrive.Rise + p->pSuperLib->tDelayInv.Fall; - // tArrInv.Rise = pMatch->tArrive.Fall + p->pSuperLib->tDelayInv.Rise; - ptReqIn->Fall = MAP_MIN( ptReqIn->Fall, ptReqOut->Rise - p->pSuperLib->tDelayInv.Rise ); - ptReqIn->Rise = MAP_MIN( ptReqIn->Rise, ptReqOut->Fall - p->pSuperLib->tDelayInv.Fall ); - } - } - - // finalize the worst case computation - pNode->tRequired[0].Worst = MAP_MIN( pNode->tRequired[0].Fall, pNode->tRequired[0].Rise ); - pNode->tRequired[1].Worst = MAP_MIN( pNode->tRequired[1].Fall, pNode->tRequired[1].Rise ); - - // skip the PIs - if ( !Map_NodeIsAnd(pNode) ) - continue; - - // propagate required times of different phases of the node - // the ordering of phases does not matter since they are mapped independently - if ( pNode->pCutBest[0] && pNode->tRequired[0].Worst < MAP_FLOAT_LARGE ) - Map_TimePropagateRequiredPhase( p, pNode, 0 ); - if ( pNode->pCutBest[1] && pNode->tRequired[1].Worst < MAP_FLOAT_LARGE ) - Map_TimePropagateRequiredPhase( p, pNode, 1 ); - } - - // in the end, we verify the required times - // for this, we compute the arrival times of the outputs of each phase - // of the supergates using the fanins' required times as the fanins' arrival times - // the resulting arrival time of the supergate should be less than the actual required time - for ( k = 0; k < vNodes->nSize; k++ ) - { - pNode = vNodes->pArray[k]; - if ( !Map_NodeIsAnd(pNode) ) - continue; - // verify that the required times are propagated correctly -// if ( pNode->pCutBest[0] && (pNode->nRefAct[0] > 0 || pNode->pCutBest[1] == NULL) ) - if ( pNode->pCutBest[0] && pNode->tRequired[0].Worst < MAP_FLOAT_LARGE ) - { - Map_MatchComputeReqTimes( pNode->pCutBest[0], 0, ptReqOutTest ); - assert( ptReqOutTest->Rise < pNode->tRequired[0].Rise + p->fEpsilon ); - assert( ptReqOutTest->Fall < pNode->tRequired[0].Fall + p->fEpsilon ); - } -// if ( pNode->pCutBest[1] && (pNode->nRefAct[1] > 0 || pNode->pCutBest[0] == NULL) ) - if ( pNode->pCutBest[1] && pNode->tRequired[1].Worst < MAP_FLOAT_LARGE ) - { - Map_MatchComputeReqTimes( pNode->pCutBest[1], 1, ptReqOutTest ); - assert( ptReqOutTest->Rise < pNode->tRequired[1].Rise + p->fEpsilon ); - assert( ptReqOutTest->Fall < pNode->tRequired[1].Fall + p->fEpsilon ); - } - } - -} - -/**Function************************************************************* - - Synopsis [Computes the required times of the given nodes.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_TimePropagateRequiredPhase( Map_Man_t * p, Map_Node_t * pNode, int fPhase ) -{ - Map_Time_t * ptReqIn, * ptReqOut; - Map_Cut_t * pCut; - Map_Super_t * pSuper; - float tNewReqTime; - unsigned uPhase; - int fPinPhase, i; - - // get the cut to be propagated - pCut = pNode->pCutBest[fPhase]; - assert( pCut != NULL ); - // get the supergate and its polarity - pSuper = pCut->M[fPhase].pSuperBest; - uPhase = pCut->M[fPhase].uPhaseBest; - // get the required time of the output of the supergate - ptReqOut = pNode->tRequired + fPhase; - // set the required time of the children - for ( i = 0; i < pCut->nLeaves; i++ ) - { - // get the phase of the given pin of the supergate - fPinPhase = ((uPhase & (1 << i)) == 0); - ptReqIn = pCut->ppLeaves[i]->tRequired + fPinPhase; - assert( pCut->ppLeaves[i]->nRefAct[2] > 0 ); - - // get the rise of the output due to rise of the inputs -// if ( ptArrOut->Rise < ptArrIn->Rise + pSuper->tDelaysR[i].Rise ) -// ptArrOut->Rise = ptArrIn->Rise + pSuper->tDelaysR[i].Rise; - if ( pSuper->tDelaysR[i].Rise > 0 ) - { - tNewReqTime = ptReqOut->Rise - pSuper->tDelaysR[i].Rise; - ptReqIn->Rise = MAP_MIN( ptReqIn->Rise, tNewReqTime ); - } - - // get the rise of the output due to fall of the inputs -// if ( ptArrOut->Rise < ptArrIn->Fall + pSuper->tDelaysR[i].Fall ) -// ptArrOut->Rise = ptArrIn->Fall + pSuper->tDelaysR[i].Fall; - if ( pSuper->tDelaysR[i].Fall > 0 ) - { - tNewReqTime = ptReqOut->Rise - pSuper->tDelaysR[i].Fall; - ptReqIn->Fall = MAP_MIN( ptReqIn->Fall, tNewReqTime ); - } - - // get the fall of the output due to rise of the inputs -// if ( ptArrOut->Fall < ptArrIn->Rise + pSuper->tDelaysF[i].Rise ) -// ptArrOut->Fall = ptArrIn->Rise + pSuper->tDelaysF[i].Rise; - if ( pSuper->tDelaysF[i].Rise > 0 ) - { - tNewReqTime = ptReqOut->Fall - pSuper->tDelaysF[i].Rise; - ptReqIn->Rise = MAP_MIN( ptReqIn->Rise, tNewReqTime ); - } - - // get the fall of the output due to fall of the inputs -// if ( ptArrOut->Fall < ptArrIn->Fall + pSuper->tDelaysF[i].Fall ) -// ptArrOut->Fall = ptArrIn->Fall + pSuper->tDelaysF[i].Fall; - if ( pSuper->tDelaysF[i].Fall > 0 ) - { - tNewReqTime = ptReqOut->Fall - pSuper->tDelaysF[i].Fall; - ptReqIn->Fall = MAP_MIN( ptReqIn->Fall, tNewReqTime ); - } - } - - // compare the required times with the arrival times - assert( pNode->tArrival[fPhase].Rise < ptReqOut->Rise + p->fEpsilon ); - assert( pNode->tArrival[fPhase].Fall < ptReqOut->Fall + p->fEpsilon ); -} - -/**Function************************************************************* - - Synopsis [Computes the arrival times of the cut.] - - Description [Computes the arrival times of the cut if it is implemented using - the given supergate with the given phase. Uses the constraint-type specification - of rise/fall arrival times.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -float Map_MatchComputeReqTimes( Map_Cut_t * pCut, int fPhase, Map_Time_t * ptArrRes ) -{ - Map_Time_t * ptArrIn; - Map_Super_t * pSuper; - unsigned uPhaseTot; - int fPinPhase, i; - float tDelay; - - // get the supergate and the phase - pSuper = pCut->M[fPhase].pSuperBest; - uPhaseTot = pCut->M[fPhase].uPhaseBest; - - // propagate the arrival times - ptArrRes->Rise = ptArrRes->Fall = -MAP_FLOAT_LARGE; - for ( i = 0; i < pCut->nLeaves; i++ ) - { - // get the phase of the given pin - fPinPhase = ((uPhaseTot & (1 << i)) == 0); - ptArrIn = pCut->ppLeaves[i]->tRequired + fPinPhase; -// assert( ptArrIn->Worst < MAP_FLOAT_LARGE ); - - // get the rise of the output due to rise of the inputs - if ( pSuper->tDelaysR[i].Rise > 0 ) - { - tDelay = ptArrIn->Rise + pSuper->tDelaysR[i].Rise; - if ( ptArrRes->Rise < tDelay ) - ptArrRes->Rise = tDelay; - } - - // get the rise of the output due to fall of the inputs - if ( pSuper->tDelaysR[i].Fall > 0 ) - { - tDelay = ptArrIn->Fall + pSuper->tDelaysR[i].Fall; - if ( ptArrRes->Rise < tDelay ) - ptArrRes->Rise = tDelay; - } - - // get the fall of the output due to rise of the inputs - if ( pSuper->tDelaysF[i].Rise > 0 ) - { - tDelay = ptArrIn->Rise + pSuper->tDelaysF[i].Rise; - if ( ptArrRes->Fall < tDelay ) - ptArrRes->Fall = tDelay; - } - - // get the fall of the output due to fall of the inputs - if ( pSuper->tDelaysF[i].Fall > 0 ) - { - tDelay = ptArrIn->Fall + pSuper->tDelaysF[i].Fall; - if ( ptArrRes->Fall < tDelay ) - ptArrRes->Fall = tDelay; - } - } - // return the worst-case of rise/fall arrival times - return MAP_MAX(ptArrRes->Rise, ptArrRes->Fall); -} - - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - - diff --git a/src/map/mapper/mapperTree.c b/src/map/mapper/mapperTree.c deleted file mode 100644 index ef66082d..00000000 --- a/src/map/mapper/mapperTree.c +++ /dev/null @@ -1,818 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapperTree.c] - - PackageName [MVSIS 1.3: Multi-valued logic synthesis system.] - - Synopsis [Generic technology mapping engine.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 2.0. Started - June 1, 2004.] - - Revision [$Id: mapperTree.c,v 1.9 2005/01/23 06:59:45 alanmi Exp $] - -***********************************************************************/ - -#ifdef __linux__ -#include -#endif - -#include "mapperInt.h" - -//////////////////////////////////////////////////////////////////////// -/// DECLARATIONS /// -//////////////////////////////////////////////////////////////////////// - -static int Map_LibraryReadFileTree( Map_SuperLib_t * pLib, FILE * pFile, char *pFileName ); -static Map_Super_t * Map_LibraryReadGateTree( Map_SuperLib_t * pLib, char * pBuffer, int Number, int nVars ); -static int Map_LibraryDeriveGateInfo( Map_SuperLib_t * pLib, st_table * tExcludeGate ); -static void Map_LibraryAddFaninDelays( Map_SuperLib_t * pLib, Map_Super_t * pGate, Map_Super_t * pFanin, Mio_Pin_t * pPin ); -static int Map_LibraryGetMaxSuperPi_rec( Map_Super_t * pGate ); -static unsigned Map_LibraryGetGateSupp_rec( Map_Super_t * pGate ); - -// fanout limits -extern const int s_MapFanoutLimits[10] = { 1/*0*/, 10/*1*/, 5/*2*/, 2/*3*/, 1/*4*/, 1/*5*/, 1/*6*/ }; - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**Function************************************************************* - - Synopsis [Reads the supergate library from file.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_LibraryReadTree( Map_SuperLib_t * pLib, char * pFileName, char * pExcludeFile ) -{ - FILE * pFile; - int Status, num; - Abc_Frame_t * pAbc; - st_table * tExcludeGate = 0; - - // read the beginning of the file - assert( pLib->pGenlib == NULL ); - pFile = Io_FileOpen( pFileName, "open_path", "r", 1 ); -// pFile = fopen( pFileName, "r" ); - if ( pFile == NULL ) - { - printf( "Cannot open input file \"%s\".\n", pFileName ); - return 0; - } - - if ( pExcludeFile ) - { - pAbc = Abc_FrameGetGlobalFrame(); - - tExcludeGate = st_init_table(strcmp, st_strhash); - if ( (num = Mio_LibraryReadExclude( pAbc, pExcludeFile, tExcludeGate )) == -1 ) - { - st_free_table( tExcludeGate ); - tExcludeGate = 0; - return 0; - } - - fprintf ( Abc_FrameReadOut( pAbc ), "Read %d gates from exclude file\n", num ); - } - - Status = Map_LibraryReadFileTree( pLib, pFile, pFileName ); - fclose( pFile ); - if ( Status == 0 ) - return 0; - // prepare the info about the library - return Map_LibraryDeriveGateInfo( pLib, tExcludeGate ); -} - - -/**Function************************************************************* - - Synopsis [Reads the library file.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_LibraryReadFileTree( Map_SuperLib_t * pLib, FILE * pFile, char *pFileName ) -{ - ProgressBar * pProgress; - char pBuffer[5000], pLibFile[5000]; - FILE * pFileGen; - Map_Super_t * pGate; - char * pTemp = 0, * pLibName; - int nCounter, k, i; - - // skip empty and comment lines - while ( fgets( pBuffer, 5000, pFile ) != NULL ) - { - // skip leading spaces - for ( pTemp = pBuffer; *pTemp == ' ' || *pTemp == '\r' || *pTemp == '\n'; pTemp++ ); - // skip comment lines and empty lines - if ( *pTemp != 0 && *pTemp != '#' ) - break; - } - - // get the genlib file name (base) - pLibName = strtok( pTemp, " \t\r\n" ); - - if ( strcmp( pLibName, "GATE" ) == 0 ) - { - printf( "The input file \"%s\" looks like a GENLIB file and not a supergate library file.\n", pLib->pName ); - return 0; - } - - - // now figure out the directory if any in the pFileName -#ifdef __linux__ - snprintf( pLibFile, 5000, "%s/%s", dirname(strdup(pFileName)), pLibName ); -#else - { - char * pStr; - strcpy( pLibFile, pFileName ); - pStr = pLibFile + strlen(pBuffer) - 1; - while ( pStr > pLibFile && *pStr != '\\' && *pStr != '/' ) - pStr--; - if ( pStr == pLibFile ) - strcpy( pLibFile, pLibName ); - else - sprintf( pStr, "/%s", pLibName ); - } -#endif - - pFileGen = Io_FileOpen( pLibFile, "open_path", "r", 1 ); -// pFileGen = fopen( pLibFile, "r" ); - if ( pFileGen == NULL ) - { - printf( "Cannot open the GENLIB file \"%s\".\n", pLibFile ); - return 0; - } - fclose( pFileGen ); - - // read the genlib library - pLib->pGenlib = Mio_LibraryRead( Abc_FrameGetGlobalFrame(), pLibFile, 0, 0 ); - if ( pLib->pGenlib == NULL ) - { - printf( "Cannot read GENLIB file \"%s\".\n", pLibFile ); - return 0; - } - - // read the number of variables - fscanf( pFile, "%d\n", &pLib->nVarsMax ); - if ( pLib->nVarsMax < 2 || pLib->nVarsMax > 10 ) - { - printf( "Suspicious number of variables (%d).\n", pLib->nVarsMax ); - return 0; - } - - // read the number of gates - fscanf( pFile, "%d\n", &pLib->nSupersReal ); - if ( pLib->nSupersReal < 1 || pLib->nSupersReal > 10000000 ) - { - printf( "Suspicious number of gates (%d).\n", pLib->nSupersReal ); - return 0; - } - - // read the number of lines - fscanf( pFile, "%d\n", &pLib->nLines ); - if ( pLib->nLines < 1 || pLib->nLines > 10000000 ) - { - printf( "Suspicious number of lines (%d).\n", pLib->nLines ); - return 0; - } - - // allocate room for supergate pointers - pLib->ppSupers = ALLOC( Map_Super_t *, pLib->nLines + 10000 ); - - // create the elementary supergates - for ( i = 0; i < pLib->nVarsMax; i++ ) - { - // get a new gate - pGate = (Map_Super_t *)Extra_MmFixedEntryFetch( pLib->mmSupers ); - memset( pGate, 0, sizeof(Map_Super_t) ); - // assign the elementary variable, the truth table, and the delays - pGate->Num = i; - // set the truth table - pGate->uTruth[0] = pLib->uTruths[i][0]; - pGate->uTruth[1] = pLib->uTruths[i][1]; - // set the arrival times of all input to non-existent delay - for ( k = 0; k < pLib->nVarsMax; k++ ) - { - pGate->tDelaysR[k].Rise = pGate->tDelaysR[k].Fall = MAP_NO_VAR; - pGate->tDelaysF[k].Rise = pGate->tDelaysF[k].Fall = MAP_NO_VAR; - } - // set an existent arrival time for rise and fall - pGate->tDelaysR[i].Rise = 0.0; - pGate->tDelaysF[i].Fall = 0.0; - // set the gate - pLib->ppSupers[i] = pGate; - } - - // read the lines - nCounter = pLib->nVarsMax; - pProgress = Extra_ProgressBarStart( stdout, pLib->nLines ); - while ( fgets( pBuffer, 5000, pFile ) != NULL ) - { - for ( pTemp = pBuffer; *pTemp == ' ' || *pTemp == '\r' || *pTemp == '\n'; pTemp++ ); - if ( pTemp[0] == '\0' ) - continue; -// if ( pTemp[0] == 'a' || pTemp[2] == 'a' ) -// { -// pLib->nLines--; -// continue; -// } - - // get the gate - pGate = Map_LibraryReadGateTree( pLib, pTemp, nCounter, pLib->nVarsMax ); - if ( pGate == NULL ) - { - Extra_ProgressBarStop( pProgress ); - return 0; - } - pLib->ppSupers[nCounter++] = pGate; - // later we will derive: truth table, delays, area, number of component gates, etc - - // update the progress bar - Extra_ProgressBarUpdate( pProgress, nCounter, NULL ); - } - Extra_ProgressBarStop( pProgress ); - if ( nCounter != pLib->nLines ) - printf( "The number of lines read (%d) is different what the file says (%d).\n", nCounter, pLib->nLines ); - pLib->nSupersAll = nCounter; - // count the number of real supergates - nCounter = 0; - for ( k = 0; k < pLib->nLines; k++ ) - nCounter += pLib->ppSupers[k]->fSuper; - if ( nCounter != pLib->nSupersReal ) - printf( "The number of gates read (%d) is different what the file says (%d).\n", nCounter, pLib->nSupersReal ); - pLib->nSupersReal = nCounter; - return 1; -} - -/**Function************************************************************* - - Synopsis [Reads one gate.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Super_t * Map_LibraryReadGateTree( Map_SuperLib_t * pLib, char * pBuffer, int Number, int nVarsMax ) -{ - Map_Super_t * pGate; - char * pTemp; - int i, Num; - - // start and clean the gate - pGate = (Map_Super_t *)Extra_MmFixedEntryFetch( pLib->mmSupers ); - memset( pGate, 0, sizeof(Map_Super_t) ); - - // set the gate number - pGate->Num = Number; - - // read the mark - pTemp = strtok( pBuffer, " " ); - if ( pTemp[0] == '*' ) - { - pGate->fSuper = 1; - pTemp = strtok( NULL, " " ); - } - - // read the root gate - pGate->pRoot = Mio_LibraryReadGateByName( pLib->pGenlib, pTemp ); - if ( pGate->pRoot == NULL ) - { - printf( "Cannot read the root gate names %s.\n", pTemp ); - return NULL; - } - // set the max number of fanouts - pGate->nFanLimit = s_MapFanoutLimits[ Mio_GateReadInputs(pGate->pRoot) ]; - - // read the pin-to-pin delay - for ( i = 0; ( pTemp = strtok( NULL, " \n\0" ) ); i++ ) - { - if ( pTemp[0] == '#' ) - break; - if ( i == nVarsMax ) - { - printf( "There are too many entries on the line.\n" ); - return NULL; - } - Num = atoi(pTemp); - if ( Num < 0 ) - { - printf( "The number of a child supergate is negative.\n" ); - return NULL; - } - if ( Num > pLib->nLines ) - { - printf( "The number of a child supergate (%d) exceeded the number of lines (%d).\n", - Num, pLib->nLines ); - return NULL; - } - pGate->pFanins[i] = pLib->ppSupers[Num]; - } - pGate->nFanins = i; - if ( pGate->nFanins != (unsigned)Mio_GateReadInputs(pGate->pRoot) ) - { - printf( "The number of fanins of a root gate is wrong.\n" ); - return NULL; - } - - // save the gate name, just in case - if ( pTemp && pTemp[0] == '#' ) - { - if ( pTemp[1] == 0 ) - pTemp = strtok( NULL, " \n\0" ); - else // skip spaces - for ( pTemp++; *pTemp == ' '; pTemp++ ); - // save the formula - pGate->pFormula = Extra_MmFlexEntryFetch( pLib->mmForms, strlen(pTemp)+1 ); - strcpy( pGate->pFormula, pTemp ); - } - // check the rest of the string - pTemp = strtok( NULL, " \n\0" ); - if ( pTemp != NULL ) - printf( "The following trailing symbols found \"%s\".\n", pTemp ); - return pGate; -} - - -/**Function************************************************************* - - Synopsis [Derives information about the library.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_LibraryDeriveGateInfo( Map_SuperLib_t * pLib, st_table * tExcludeGate ) -{ - Map_Super_t * pGate, * pFanin; - Mio_Pin_t * pPin; - unsigned uCanon[2]; - unsigned uTruths[6][2]; - int i, k, nRealVars; - - // set all the derivable info related to the supergates - for ( i = pLib->nVarsMax; i < (int)pLib->nLines; i++ ) - { - pGate = pLib->ppSupers[i]; - - if ( tExcludeGate ) - { - if ( st_is_member( tExcludeGate, Mio_GateReadName( pGate->pRoot ) ) ) - pGate->fExclude = 1; - for ( k = 0; k < (int)pGate->nFanins; k++ ) - { - pFanin = pGate->pFanins[k]; - if ( pFanin->fExclude ) - { - pGate->fExclude = 1; - continue; - } - } - } - - // collect the truth tables of the fanins - for ( k = 0; k < (int)pGate->nFanins; k++ ) - { - pFanin = pGate->pFanins[k]; - uTruths[k][0] = pFanin->uTruth[0]; - uTruths[k][1] = pFanin->uTruth[1]; - } - // derive the new truth table - Mio_DeriveTruthTable( pGate->pRoot, uTruths, pGate->nFanins, 6, pGate->uTruth ); - - // set the initial delays of the supergate - for ( k = 0; k < pLib->nVarsMax; k++ ) - { - pGate->tDelaysR[k].Rise = pGate->tDelaysR[k].Fall = MAP_NO_VAR; - pGate->tDelaysF[k].Rise = pGate->tDelaysF[k].Fall = MAP_NO_VAR; - } - // get the linked list of pins for the given root gate - pPin = Mio_GateReadPins( pGate->pRoot ); - // update the initial delay of the supergate using info from the corresponding pin - for ( k = 0; k < (int)pGate->nFanins; k++, pPin = Mio_PinReadNext(pPin) ) - { - // if there is no corresponding pin, this is a bug, return fail - if ( pPin == NULL ) - { - printf( "There are less pins than gate inputs.\n" ); - return 0; - } - // update the delay information of k-th fanins info from the corresponding pin - Map_LibraryAddFaninDelays( pLib, pGate, pGate->pFanins[k], pPin ); - } - // if there are some pins left, this is a bug, return fail - if ( pPin != NULL ) - { - printf( "There are more pins than gate inputs.\n" ); - return 0; - } - // find the max delay - pGate->tDelayMax.Rise = pGate->tDelayMax.Fall = MAP_NO_VAR; - for ( k = 0; k < pLib->nVarsMax; k++ ) - { - // the rise of the output depends on the rise and fall of the output - if ( pGate->tDelayMax.Rise < pGate->tDelaysR[k].Rise ) - pGate->tDelayMax.Rise = pGate->tDelaysR[k].Rise; - if ( pGate->tDelayMax.Rise < pGate->tDelaysR[k].Fall ) - pGate->tDelayMax.Rise = pGate->tDelaysR[k].Fall; - // the fall of the output depends on the rise and fall of the output - if ( pGate->tDelayMax.Fall < pGate->tDelaysF[k].Rise ) - pGate->tDelayMax.Fall = pGate->tDelaysF[k].Rise; - if ( pGate->tDelayMax.Fall < pGate->tDelaysF[k].Fall ) - pGate->tDelayMax.Fall = pGate->tDelaysF[k].Fall; - - pGate->tDelaysF[k].Worst = MAP_MAX( pGate->tDelaysF[k].Fall, pGate->tDelaysF[k].Rise ); - pGate->tDelaysR[k].Worst = MAP_MAX( pGate->tDelaysR[k].Fall, pGate->tDelaysR[k].Rise ); - } - - // count gates and area of the supergate - pGate->nGates = 1; - pGate->Area = (float)Mio_GateReadArea(pGate->pRoot); - for ( k = 0; k < (int)pGate->nFanins; k++ ) - { - pGate->nGates += pGate->pFanins[k]->nGates; - pGate->Area += pGate->pFanins[k]->Area; - } - // do not add the gate to the table, if this gate is an internal gate - // of some supegate and does not correspond to a supergate output - if ( ( !pGate->fSuper ) || pGate->fExclude ) - continue; - - // find the maximum index of a variable in the support of the supergates - // this is important for two reasons: - // (1) to limit the number of permutations considered for canonicization - // (2) to get rid of equivalence phases to speed-up matching - nRealVars = Map_LibraryGetMaxSuperPi_rec( pGate ) + 1; - assert( nRealVars > 0 && nRealVars <= pLib->nVarsMax ); - // if there are some problems with this code, try this instead -// nRealVars = pLib->nVarsMax; - - // find the N-canonical form of this supergate - pGate->nPhases = Map_CanonComputeSlow( pLib->uTruths, pLib->nVarsMax, nRealVars, pGate->uTruth, pGate->uPhases, uCanon ); - // add the supergate into the table by its N-canonical table - Map_SuperTableInsertC( pLib->tTableC, uCanon, pGate ); -/* - { - int uCanon1, uCanon2; - uCanon1 = uCanon[0]; - pGate->uTruth[0] = ~pGate->uTruth[0]; - pGate->uTruth[1] = ~pGate->uTruth[1]; - Map_CanonComputeSlow( pLib->uTruths, pLib->nVarsMax, nRealVars, pGate->uTruth, pGate->uPhases, uCanon ); - uCanon2 = uCanon[0]; -Rwt_Man5ExploreCount( uCanon1 < uCanon2 ? uCanon1 : uCanon2 ); - } -*/ - } - // sort the gates in each line - Map_SuperTableSortSupergatesByDelay( pLib->tTableC, pLib->nSupersAll ); - - // let the glory be manifest -// Map_LibraryPrintTree( pLib ); - return 1; -} - -/**Function************************************************************* - - Synopsis [Finds the largest PI number in the support of the supergate.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_LibraryGetMaxSuperPi_rec( Map_Super_t * pGate ) -{ - int i, VarCur, VarMax = 0; - if ( pGate->pRoot == NULL ) - return pGate->Num; - for ( i = 0; i < (int)pGate->nFanins; i++ ) - { - VarCur = Map_LibraryGetMaxSuperPi_rec( pGate->pFanins[i] ); - if ( VarMax < VarCur ) - VarMax = VarCur; - } - return VarMax; -} - -/**Function************************************************************* - - Synopsis [Finds the largest PI number in the support of the supergate.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -unsigned Map_LibraryGetGateSupp_rec( Map_Super_t * pGate ) -{ - unsigned uSupport; - int i; - if ( pGate->pRoot == NULL ) - return (unsigned)(1 << (pGate->Num)); - uSupport = 0; - for ( i = 0; i < (int)pGate->nFanins; i++ ) - uSupport |= Map_LibraryGetGateSupp_rec( pGate->pFanins[i] ); - return uSupport; -} - -/**Function************************************************************* - - Synopsis [Derives the pin-to-pin delay constraints for the supergate.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_LibraryAddFaninDelays( Map_SuperLib_t * pLib, Map_Super_t * pGate, Map_Super_t * pFanin, Mio_Pin_t * pPin ) -{ - Mio_PinPhase_t PinPhase; - float tDelayBlockRise, tDelayBlockFall, tDelayPin; - bool fMaxDelay = 0; - int i; - - // use this node to enable max-delay model - if ( fMaxDelay ) - { - float tDelayBlockMax; - // get the maximum delay - tDelayBlockMax = (float)Mio_PinReadDelayBlockMax(pPin); - // go through the supergate inputs - for ( i = 0; i < pLib->nVarsMax; i++ ) - { - if ( pFanin->tDelaysR[i].Rise < 0 ) - continue; - tDelayPin = pFanin->tDelaysR[i].Rise + tDelayBlockMax; - if ( pGate->tDelaysR[i].Rise < tDelayPin ) - pGate->tDelaysR[i].Rise = tDelayPin; - } - // go through the supergate inputs - for ( i = 0; i < pLib->nVarsMax; i++ ) - { - if ( pFanin->tDelaysF[i].Fall < 0 ) - continue; - tDelayPin = pFanin->tDelaysF[i].Fall + tDelayBlockMax; - if ( pGate->tDelaysF[i].Fall < tDelayPin ) - pGate->tDelaysF[i].Fall = tDelayPin; - } - return; - } - - // get the interesting parameters of this pin - PinPhase = Mio_PinReadPhase(pPin); - tDelayBlockRise = (float)Mio_PinReadDelayBlockRise( pPin ); - tDelayBlockFall = (float)Mio_PinReadDelayBlockFall( pPin ); - - // update the rise and fall of the output depending on the phase of the pin - if ( PinPhase != MIO_PHASE_INV ) // NONINV phase is present - { - // the rise of the gate is determined by the rise of the fanin - // the fall of the gate is determined by the fall of the fanin - for ( i = 0; i < pLib->nVarsMax; i++ ) - { - //////////////////////////////////////////////////////// - // consider the rise of the gate - //////////////////////////////////////////////////////// - // check two types of constraints on the rise of the fanin: - // (1) the constraints related to the rise of the PIs - // (2) the constraints related to the fall of the PIs - if ( pFanin->tDelaysR[i].Rise >= 0 ) // case (1) - { // fanin's rise depends on the rise of i-th PI - // update the rise of the gate's output - if ( pGate->tDelaysR[i].Rise < pFanin->tDelaysR[i].Rise + tDelayBlockRise ) - pGate->tDelaysR[i].Rise = pFanin->tDelaysR[i].Rise + tDelayBlockRise; - } - if ( pFanin->tDelaysR[i].Fall >= 0 ) // case (2) - { // fanin's rise depends on the fall of i-th PI - // update the rise of the gate's output - if ( pGate->tDelaysR[i].Fall < pFanin->tDelaysR[i].Fall + tDelayBlockRise ) - pGate->tDelaysR[i].Fall = pFanin->tDelaysR[i].Fall + tDelayBlockRise; - } - //////////////////////////////////////////////////////// - - //////////////////////////////////////////////////////// - // consider the fall of the gate (similar) - //////////////////////////////////////////////////////// - // check two types of constraints on the fall of the fanin: - // (1) the constraints related to the rise of the PIs - // (2) the constraints related to the fall of the PIs - if ( pFanin->tDelaysF[i].Rise >= 0 ) // case (1) - { - if ( pGate->tDelaysF[i].Rise < pFanin->tDelaysF[i].Rise + tDelayBlockFall ) - pGate->tDelaysF[i].Rise = pFanin->tDelaysF[i].Rise + tDelayBlockFall; - } - if ( pFanin->tDelaysF[i].Fall >= 0 ) // case (2) - { - if ( pGate->tDelaysF[i].Fall < pFanin->tDelaysF[i].Fall + tDelayBlockFall ) - pGate->tDelaysF[i].Fall = pFanin->tDelaysF[i].Fall + tDelayBlockFall; - } - //////////////////////////////////////////////////////// - } - } - if ( PinPhase != MIO_PHASE_NONINV ) // INV phase is present - { - // the rise of the gate is determined by the fall of the fanin - // the fall of the gate is determined by the rise of the fanin - for ( i = 0; i < pLib->nVarsMax; i++ ) - { - //////////////////////////////////////////////////////// - // consider the rise of the gate's output - //////////////////////////////////////////////////////// - // check two types of constraints on the fall of the fanin: - // (1) the constraints related to the rise of the PIs - // (2) the constraints related to the fall of the PIs - if ( pFanin->tDelaysF[i].Rise >= 0 ) // case (1) - { // fanin's rise depends on the rise of i-th PI - // update the rise of the gate - if ( pGate->tDelaysR[i].Rise < pFanin->tDelaysF[i].Rise + tDelayBlockRise ) - pGate->tDelaysR[i].Rise = pFanin->tDelaysF[i].Rise + tDelayBlockRise; - } - if ( pFanin->tDelaysF[i].Fall >= 0 ) // case (2) - { // fanin's rise depends on the fall of i-th PI - // update the rise of the gate - if ( pGate->tDelaysR[i].Fall < pFanin->tDelaysF[i].Fall + tDelayBlockRise ) - pGate->tDelaysR[i].Fall = pFanin->tDelaysF[i].Fall + tDelayBlockRise; - } - //////////////////////////////////////////////////////// - - //////////////////////////////////////////////////////// - // consider the fall of the gate (similar) - //////////////////////////////////////////////////////// - // check two types of constraints on the rise of the fanin: - // (1) the constraints related to the rise of the PIs - // (2) the constraints related to the fall of the PIs - if ( pFanin->tDelaysR[i].Rise >= 0 ) // case (1) - { - if ( pGate->tDelaysF[i].Rise < pFanin->tDelaysR[i].Rise + tDelayBlockFall ) - pGate->tDelaysF[i].Rise = pFanin->tDelaysR[i].Rise + tDelayBlockFall; - } - if ( pFanin->tDelaysR[i].Fall >= 0 ) // case (2) - { - if ( pGate->tDelaysF[i].Fall < pFanin->tDelaysR[i].Fall + tDelayBlockFall ) - pGate->tDelaysF[i].Fall = pFanin->tDelaysR[i].Fall + tDelayBlockFall; - } - //////////////////////////////////////////////////////// - } - } -} - - -/**Function************************************************************* - - Synopsis [Performs phase transformation for one function.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -unsigned Map_CalculatePhase( unsigned uTruths[][2], int nVars, unsigned uTruth, unsigned uPhase ) -{ - int v, Shift; - for ( v = 0, Shift = 1; v < nVars; v++, Shift <<= 1 ) - if ( uPhase & Shift ) - uTruth = (((uTruth & ~uTruths[v][0]) << Shift) | ((uTruth & uTruths[v][0]) >> Shift)); - return uTruth; -} - -/**Function************************************************************* - - Synopsis [Performs phase transformation for one function.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_CalculatePhase6( unsigned uTruths[][2], int nVars, unsigned uTruth[], unsigned uPhase, unsigned uTruthRes[] ) -{ - unsigned uTemp; - int v, Shift; - - // initialize the result - uTruthRes[0] = uTruth[0]; - uTruthRes[1] = uTruth[1]; - if ( uPhase == 0 ) - return; - // compute the phase - for ( v = 0, Shift = 1; v < nVars; v++, Shift <<= 1 ) - if ( uPhase & Shift ) - { - if ( Shift < 32 ) - { - uTruthRes[0] = (((uTruthRes[0] & ~uTruths[v][0]) << Shift) | ((uTruthRes[0] & uTruths[v][0]) >> Shift)); - uTruthRes[1] = (((uTruthRes[1] & ~uTruths[v][1]) << Shift) | ((uTruthRes[1] & uTruths[v][1]) >> Shift)); - } - else - { - uTemp = uTruthRes[0]; - uTruthRes[0] = uTruthRes[1]; - uTruthRes[1] = uTemp; - } - } -} - -/**Function************************************************************* - - Synopsis [Prints the supergate library after deriving parameters.] - - Description [This procedure is very useful to see the library after - it has been read into the mapper by "read_super" and all the information - about the supergates derived.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_LibraryPrintTree( Map_SuperLib_t * pLib ) -{ - Map_Super_t * pGate; - int i, k; - - // print all the info related to the supergates -// for ( i = pLib->nVarsMax; i < (int)pLib->nLines; i++ ) - for ( i = pLib->nVarsMax; i < 20; i++ ) - { - pGate = pLib->ppSupers[i]; - - // write the gate's fanin info and formula - printf( "%6d ", pGate->Num ); - printf( "%c ", pGate->fSuper? '*' : ' ' ); - printf( "%6s", Mio_GateReadName(pGate->pRoot) ); - for ( k = 0; k < (int)pGate->nFanins; k++ ) - printf( " %6d", pGate->pFanins[k]->Num ); - printf( " %s", pGate->pFormula ); - printf( "\n" ); - - // write the gate's derived info - Extra_PrintBinary( stdout, pGate->uTruth, 64 ); - printf( " %3d", pGate->nGates ); - printf( " %6.2f", pGate->Area ); - printf( " (%4.2f, %4.2f)", pGate->tDelayMax.Rise, pGate->tDelayMax.Fall ); - printf( "\n" ); - for ( k = 0; k < pLib->nVarsMax; k++ ) - { - // print the constraint on the rise of the gate in the form (D1, D2), - // where D1 is the constraint related to the rise of the k-th PI - // where D2 is the constraint related to the fall of the k-th PI - if ( pGate->tDelaysR[k].Rise < 0 && pGate->tDelaysR[k].Fall < 0 ) - printf( " (----, ----)" ); - else if ( pGate->tDelaysR[k].Fall < 0 ) - printf( " (%4.2f, ----)", pGate->tDelaysR[k].Rise ); - else if ( pGate->tDelaysR[k].Rise < 0 ) - printf( " (----, %4.2f)", pGate->tDelaysR[k].Fall ); - else - printf( " (%4.2f, %4.2f)", pGate->tDelaysR[k].Rise, pGate->tDelaysR[k].Fall ); - - // print the constraint on the fall of the gate in the form (D1, D2), - // where D1 is the constraint related to the rise of the k-th PI - // where D2 is the constraint related to the fall of the k-th PI - if ( pGate->tDelaysF[k].Rise < 0 && pGate->tDelaysF[k].Fall < 0 ) - printf( " (----, ----)" ); - else if ( pGate->tDelaysF[k].Fall < 0 ) - printf( " (%4.2f, ----)", pGate->tDelaysF[k].Rise ); - else if ( pGate->tDelaysF[k].Rise < 0 ) - printf( " (----, %4.2f)", pGate->tDelaysF[k].Fall ); - else - printf( " (%4.2f, %4.2f)", pGate->tDelaysF[k].Rise, pGate->tDelaysF[k].Fall ); - printf( "\n" ); - } - printf( "\n" ); - } -} - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - - diff --git a/src/map/mapper/mapperTruth.c b/src/map/mapper/mapperTruth.c deleted file mode 100644 index 388b6dd3..00000000 --- a/src/map/mapper/mapperTruth.c +++ /dev/null @@ -1,310 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapperTruth.c] - - PackageName [MVSIS 1.3: Multi-valued logic synthesis system.] - - Synopsis [Generic technology mapping engine.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 2.0. Started - June 1, 2004.] - - Revision [$Id: mapperTruth.c,v 1.8 2005/01/23 06:59:45 alanmi Exp $] - -***********************************************************************/ - -#include "mapperInt.h" - -//////////////////////////////////////////////////////////////////////// -/// DECLARATIONS /// -//////////////////////////////////////////////////////////////////////// - -static void Map_TruthsCut( Map_Man_t * pMan, Map_Cut_t * pCut ); -extern void Map_TruthsCutOne( Map_Man_t * p, Map_Cut_t * pCut, unsigned uTruth[] ); -static void Map_CutsCollect_rec( Map_Cut_t * pCut, Map_NodeVec_t * vVisited ); - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**Function************************************************************* - - Synopsis [Derives truth tables for each cut.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingTruths( Map_Man_t * pMan ) -{ - ProgressBar * pProgress; - Map_Node_t * pNode; - Map_Cut_t * pCut; - int nNodes, i; - // compute the cuts for the POs - nNodes = pMan->vAnds->nSize; - pProgress = Extra_ProgressBarStart( stdout, nNodes ); - for ( i = 0; i < nNodes; i++ ) - { - pNode = pMan->vAnds->pArray[i]; - if ( !Map_NodeIsAnd( pNode ) ) - continue; - assert( pNode->pCuts ); - assert( pNode->pCuts->nLeaves == 1 ); - - // match the simple cut - pNode->pCuts->M[0].uPhase = 0; - pNode->pCuts->M[0].pSupers = pMan->pSuperLib->pSuperInv; - pNode->pCuts->M[0].uPhaseBest = 0; - pNode->pCuts->M[0].pSuperBest = pMan->pSuperLib->pSuperInv; - - pNode->pCuts->M[1].uPhase = 0; - pNode->pCuts->M[1].pSupers = pMan->pSuperLib->pSuperInv; - pNode->pCuts->M[1].uPhaseBest = 1; - pNode->pCuts->M[1].pSuperBest = pMan->pSuperLib->pSuperInv; - - // match the rest of the cuts - for ( pCut = pNode->pCuts->pNext; pCut; pCut = pCut->pNext ) - Map_TruthsCut( pMan, pCut ); - Extra_ProgressBarUpdate( pProgress, i, "Tables ..." ); - } - Extra_ProgressBarStop( pProgress ); -} - -/**Function************************************************************* - - Synopsis [Derives the truth table for one cut.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_TruthsCut( Map_Man_t * p, Map_Cut_t * pCut ) -{ -// unsigned uCanon1, uCanon2; - unsigned uTruth[2], uCanon[2]; - unsigned char uPhases[16]; - unsigned * uCanon2; - char * pPhases2; - int fUseFast = 1; - int fUseSlow = 0; - int fUseRec = 0; // this does not work for Solaris - - extern int Map_CanonCompute( int nVarsMax, int nVarsReal, unsigned * pt, unsigned ** pptRes, char ** ppfRes ); - - // generally speaking, 1-input cut can be matched into a wire! - if ( pCut->nLeaves == 1 ) - return; -/* - if ( p->nVarsMax == 5 ) - { - uTruth[0] = pCut->uTruth; - uTruth[1] = pCut->uTruth; - } - else -*/ - Map_TruthsCutOne( p, pCut, uTruth ); - - - // compute the canonical form for the positive phase - if ( fUseFast ) - Map_CanonComputeFast( p, p->nVarsMax, pCut->nLeaves, uTruth, uPhases, uCanon ); - else if ( fUseSlow ) - Map_CanonComputeSlow( p->uTruths, p->nVarsMax, pCut->nLeaves, uTruth, uPhases, uCanon ); - else if ( fUseRec ) - { -// Map_CanonComputeSlow( p->uTruths, p->nVarsMax, pCut->nLeaves, uTruth, uPhases, uCanon ); - Extra_TruthCanonFastN( p->nVarsMax, pCut->nLeaves, uTruth, &uCanon2, &pPhases2 ); -/* - if ( uCanon[0] != uCanon2[0] || uPhases[0] != pPhases2[0] ) - { - int k = 0; - Map_CanonCompute( p->nVarsMax, pCut->nLeaves, uTruth, &uCanon2, &pPhases2 ); - } -*/ - uCanon[0] = uCanon2[0]; - uCanon[1] = (p->nVarsMax == 6)? uCanon2[1] : uCanon2[0]; - uPhases[0] = pPhases2[0]; - } - else - Map_CanonComputeSlow( p->uTruths, p->nVarsMax, pCut->nLeaves, uTruth, uPhases, uCanon ); - pCut->M[1].pSupers = Map_SuperTableLookupC( p->pSuperLib, uCanon ); - pCut->M[1].uPhase = uPhases[0]; - p->nCanons++; - -//uCanon1 = uCanon[0] & 0xFFFF; - - // compute the canonical form for the negative phase - uTruth[0] = ~uTruth[0]; - uTruth[1] = ~uTruth[1]; - if ( fUseFast ) - Map_CanonComputeFast( p, p->nVarsMax, pCut->nLeaves, uTruth, uPhases, uCanon ); - else if ( fUseSlow ) - Map_CanonComputeSlow( p->uTruths, p->nVarsMax, pCut->nLeaves, uTruth, uPhases, uCanon ); - else if ( fUseRec ) - { -// Map_CanonComputeSlow( p->uTruths, p->nVarsMax, pCut->nLeaves, uTruth, uPhases, uCanon ); - Extra_TruthCanonFastN( p->nVarsMax, pCut->nLeaves, uTruth, &uCanon2, &pPhases2 ); -/* - if ( uCanon[0] != uCanon2[0] || uPhases[0] != pPhases2[0] ) - { - int k = 0; - Map_CanonCompute( p->nVarsMax, pCut->nLeaves, uTruth, &uCanon2, &pPhases2 ); - } -*/ - uCanon[0] = uCanon2[0]; - uCanon[1] = (p->nVarsMax == 6)? uCanon2[1] : uCanon2[0]; - uPhases[0] = pPhases2[0]; - } - else - Map_CanonComputeSlow( p->uTruths, p->nVarsMax, pCut->nLeaves, uTruth, uPhases, uCanon ); - pCut->M[0].pSupers = Map_SuperTableLookupC( p->pSuperLib, uCanon ); - pCut->M[0].uPhase = uPhases[0]; - p->nCanons++; - -//uCanon2 = uCanon[0] & 0xFFFF; -//assert( p->nVarsMax == 4 ); -//Rwt_Man4ExploreCount( uCanon1 < uCanon2 ? uCanon1 : uCanon2 ); - - // restore the truth table - uTruth[0] = ~uTruth[0]; - uTruth[1] = ~uTruth[1]; -} - -/**Function************************************************************* - - Synopsis [Computes the truth table of one cut.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_TruthsCutOne( Map_Man_t * p, Map_Cut_t * pCut, unsigned uTruth[] ) -{ - unsigned uTruth1[2], uTruth2[2]; - Map_Cut_t * pTemp; - int i; - // mark the cut leaves - for ( i = 0; i < pCut->nLeaves; i++ ) - { - pTemp = pCut->ppLeaves[i]->pCuts; - pTemp->fMark = 1; - pTemp->M[0].uPhaseBest = p->uTruths[i][0]; - pTemp->M[1].uPhaseBest = p->uTruths[i][1]; - } - assert( pCut->fMark == 0 ); - - // collect the cuts in the cut cone - p->vVisited->nSize = 0; - Map_CutsCollect_rec( pCut, p->vVisited ); - assert( p->vVisited->nSize > 0 ); - pCut->nVolume = p->vVisited->nSize; - - // compute the tables and unmark - for ( i = 0; i < pCut->nLeaves; i++ ) - { - pTemp = pCut->ppLeaves[i]->pCuts; - pTemp->fMark = 0; - } - for ( i = 0; i < p->vVisited->nSize; i++ ) - { - // get the cut - pTemp = (Map_Cut_t *)p->vVisited->pArray[i]; - pTemp->fMark = 0; - // get truth table of the first branch - if ( Map_CutIsComplement(pTemp->pOne) ) - { - uTruth1[0] = ~Map_CutRegular(pTemp->pOne)->M[0].uPhaseBest; - uTruth1[1] = ~Map_CutRegular(pTemp->pOne)->M[1].uPhaseBest; - } - else - { - uTruth1[0] = Map_CutRegular(pTemp->pOne)->M[0].uPhaseBest; - uTruth1[1] = Map_CutRegular(pTemp->pOne)->M[1].uPhaseBest; - } - // get truth table of the second branch - if ( Map_CutIsComplement(pTemp->pTwo) ) - { - uTruth2[0] = ~Map_CutRegular(pTemp->pTwo)->M[0].uPhaseBest; - uTruth2[1] = ~Map_CutRegular(pTemp->pTwo)->M[1].uPhaseBest; - } - else - { - uTruth2[0] = Map_CutRegular(pTemp->pTwo)->M[0].uPhaseBest; - uTruth2[1] = Map_CutRegular(pTemp->pTwo)->M[1].uPhaseBest; - } - // get the truth table of the output - if ( !pTemp->Phase ) - { - pTemp->M[0].uPhaseBest = uTruth1[0] & uTruth2[0]; - pTemp->M[1].uPhaseBest = uTruth1[1] & uTruth2[1]; - } - else - { - pTemp->M[0].uPhaseBest = ~(uTruth1[0] & uTruth2[0]); - pTemp->M[1].uPhaseBest = ~(uTruth1[1] & uTruth2[1]); - } - } - uTruth[0] = pTemp->M[0].uPhaseBest; - uTruth[1] = pTemp->M[1].uPhaseBest; -} - -/**Function************************************************************* - - Synopsis [Recursively collect the cuts.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_CutsCollect_rec( Map_Cut_t * pCut, Map_NodeVec_t * vVisited ) -{ - if ( pCut->fMark ) - return; - Map_CutsCollect_rec( Map_CutRegular(pCut->pOne), vVisited ); - Map_CutsCollect_rec( Map_CutRegular(pCut->pTwo), vVisited ); - assert( pCut->fMark == 0 ); - pCut->fMark = 1; - Map_NodeVecPush( vVisited, (Map_Node_t *)pCut ); -} - -/* - { - unsigned * uCanon2; - char * pPhases2; - - Map_CanonComputeSlow( p->uTruths, p->nVarsMax, pCut->nLeaves, uTruth, uPhases, uCanon ); - Map_CanonCompute( p->nVarsMax, pCut->nLeaves, uTruth, &uCanon2, &pPhases2 ); - if ( uCanon2[0] != uCanon[0] ) - { - int v = 0; - Map_CanonCompute( p->nVarsMax, pCut->nLeaves, uTruth, &uCanon2, &pPhases2 ); - Map_CanonComputeFast( p, p->nVarsMax, pCut->nLeaves, uTruth, uPhases, uCanon ); - } -// else -// { -// printf( "Correct.\n" ); -// } - } -*/ - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - - diff --git a/src/map/mapper/mapperUtils.c b/src/map/mapper/mapperUtils.c deleted file mode 100644 index 11a3a683..00000000 --- a/src/map/mapper/mapperUtils.c +++ /dev/null @@ -1,1154 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapperUtils.c] - - PackageName [MVSIS 1.3: Multi-valued logic synthesis system.] - - Synopsis [Generic technology mapping engine.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 2.0. Started - June 1, 2004.] - - Revision [$Id: mapperUtils.c,v 1.8 2004/11/03 22:41:45 satrajit Exp $] - -***********************************************************************/ - -#include "mapperInt.h" - -//////////////////////////////////////////////////////////////////////// -/// DECLARATIONS /// -//////////////////////////////////////////////////////////////////////// - -#define MAP_CO_LIST_SIZE 5 - -static void Map_MappingDfs_rec( Map_Node_t * pNode, Map_NodeVec_t * vNodes, int fCollectEquiv ); -static int Map_MappingCountLevels_rec( Map_Node_t * pNode ); -static float Map_MappingSetRefsAndArea_rec( Map_Man_t * pMan, Map_Node_t * pNode ); -static float Map_MappingSetRefsAndSwitch_rec( Map_Man_t * pMan, Map_Node_t * pNode ); -static float Map_MappingSetRefsAndWire_rec( Map_Man_t * pMan, Map_Node_t * pNode ); -static void Map_MappingDfsCuts_rec( Map_Node_t * pNode, Map_NodeVec_t * vNodes ); -static float Map_MappingArea_rec( Map_Man_t * pMan, Map_Node_t * pNode, Map_NodeVec_t * vNodes ); -static int Map_MappingCompareOutputDelay( Map_Node_t ** ppNode1, Map_Node_t ** ppNode2 ); -static void Map_MappingFindLatest( Map_Man_t * p, int * pNodes, int nNodesMax ); -static unsigned Map_MappingExpandTruth_rec( unsigned uTruth, int nVars ); -static void Map_MappingGetChoiceLevels( Map_Man_t * pMan, Map_Node_t * p1, Map_Node_t * p2, int * pMin, int * pMax ); -static float Map_MappingGetChoiceVolumes( Map_Man_t * pMan, Map_Node_t * p1, Map_Node_t * p2 ); -static int Map_MappingCountUsedNodes( Map_Man_t * pMan, int fChoices ); -static Map_Man_t * s_pMan = NULL; - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - - -/**Function************************************************************* - - Synopsis [Computes the DFS ordering of the nodes.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_NodeVec_t * Map_MappingDfs( Map_Man_t * pMan, int fCollectEquiv ) -{ - Map_NodeVec_t * vNodes; - int i; - // perform the traversal - vNodes = Map_NodeVecAlloc( 100 ); - for ( i = 0; i < pMan->nOutputs; i++ ) - Map_MappingDfs_rec( Map_Regular(pMan->pOutputs[i]), vNodes, fCollectEquiv ); - for ( i = 0; i < vNodes->nSize; i++ ) - vNodes->pArray[i]->fMark0 = 0; -// for ( i = 0; i < pMan->nOutputs; i++ ) -// Map_MappingUnmark_rec( Map_Regular(pMan->pOutputs[i]) ); - return vNodes; -} - -/**Function************************************************************* - - Synopsis [Computes the DFS ordering of the nodes.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_NodeVec_t * Map_MappingDfsNodes( Map_Man_t * pMan, Map_Node_t ** ppCuts, int nNodes, int fEquiv ) -{ - Map_NodeVec_t * vNodes; - int i; - // perform the traversal - vNodes = Map_NodeVecAlloc( 200 ); - for ( i = 0; i < nNodes; i++ ) - Map_MappingDfs_rec( ppCuts[i], vNodes, fEquiv ); - for ( i = 0; i < vNodes->nSize; i++ ) - vNodes->pArray[i]->fMark0 = 0; - return vNodes; -} - -/**Function************************************************************* - - Synopsis [Recursively computes the DFS ordering of the nodes.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingDfs_rec( Map_Node_t * pNode, Map_NodeVec_t * vNodes, int fCollectEquiv ) -{ - assert( !Map_IsComplement(pNode) ); - if ( pNode->fMark0 ) - return; - // visit the transitive fanin - if ( Map_NodeIsAnd(pNode) ) - { - Map_MappingDfs_rec( Map_Regular(pNode->p1), vNodes, fCollectEquiv ); - Map_MappingDfs_rec( Map_Regular(pNode->p2), vNodes, fCollectEquiv ); - } - // visit the equivalent nodes - if ( fCollectEquiv && pNode->pNextE ) - Map_MappingDfs_rec( pNode->pNextE, vNodes, fCollectEquiv ); - // make sure the node is not visited through the equivalent nodes - assert( pNode->fMark0 == 0 ); - // mark the node as visited - pNode->fMark0 = 1; - // add the node to the list - Map_NodeVecPush( vNodes, pNode ); -} - - - -/**Function************************************************************* - - Synopsis [Recursively computes the DFS ordering of the nodes.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingDfsMarked1_rec( Map_Node_t * pNode, Map_NodeVec_t * vNodes, int fFirst ) -{ - assert( !Map_IsComplement(pNode) ); - if ( pNode->fMark0 ) - return; - // visit the transitive fanin - if ( Map_NodeIsAnd(pNode) ) - { - Map_MappingDfsMarked1_rec( Map_Regular(pNode->p1), vNodes, 0 ); - Map_MappingDfsMarked1_rec( Map_Regular(pNode->p2), vNodes, 0 ); - } - // visit the equivalent nodes - if ( !fFirst && pNode->pNextE ) - Map_MappingDfsMarked1_rec( pNode->pNextE, vNodes, 0 ); - // make sure the node is not visited through the equivalent nodes - assert( pNode->fMark0 == 0 ); - // mark the node as visited - pNode->fMark0 = 1; - // add the node to the list - Map_NodeVecPush( vNodes, pNode ); -} - -/**Function************************************************************* - - Synopsis [Recursively computes the DFS ordering of the nodes.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingDfsMarked2_rec( Map_Node_t * pNode, Map_NodeVec_t * vNodes, Map_NodeVec_t * vBoundary, int fFirst ) -{ - assert( !Map_IsComplement(pNode) ); - if ( pNode->fMark1 ) - return; - if ( pNode->fMark0 || Map_NodeIsVar(pNode) ) - { - pNode->fMark1 = 1; - Map_NodeVecPush(vBoundary, pNode); - return; - } - // visit the transitive fanin - if ( Map_NodeIsAnd(pNode) ) - { - Map_MappingDfsMarked2_rec( Map_Regular(pNode->p1), vNodes, vBoundary, 0 ); - Map_MappingDfsMarked2_rec( Map_Regular(pNode->p2), vNodes, vBoundary, 0 ); - } - // visit the equivalent nodes - if ( !fFirst && pNode->pNextE ) - Map_MappingDfsMarked2_rec( pNode->pNextE, vNodes, vBoundary, 0 ); - // make sure the node is not visited through the equivalent nodes - assert( pNode->fMark1 == 0 ); - // mark the node as visited - pNode->fMark1 = 1; - // add the node to the list - Map_NodeVecPush( vNodes, pNode ); -} - - -/**Function************************************************************* - - Synopsis [Recursively computes the DFS ordering of the nodes.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingDfsMarked3_rec( Map_Node_t * pNode, Map_NodeVec_t * vNodes ) -{ - assert( !Map_IsComplement(pNode) ); - if ( pNode->fMark0 ) - return; - // visit the transitive fanin - if ( Map_NodeIsAnd(pNode) ) - { - Map_MappingDfsMarked3_rec( Map_Regular(pNode->p1), vNodes ); - Map_MappingDfsMarked3_rec( Map_Regular(pNode->p2), vNodes ); - } - // make sure the node is not visited through the equivalent nodes - assert( pNode->fMark0 == 0 ); - // mark the node as visited - pNode->fMark0 = 1; - // add the node to the list - Map_NodeVecPush( vNodes, pNode ); -} - -/**Function************************************************************* - - Synopsis [Recursively computes the DFS ordering of the nodes.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingDfsMarked4_rec( Map_Node_t * pNode, Map_NodeVec_t * vNodes ) -{ - assert( !Map_IsComplement(pNode) ); - if ( pNode->fMark1 ) - return; - // visit the transitive fanin - if ( Map_NodeIsAnd(pNode) ) - { - Map_MappingDfsMarked4_rec( Map_Regular(pNode->p1), vNodes ); - Map_MappingDfsMarked4_rec( Map_Regular(pNode->p2), vNodes ); - } - // make sure the node is not visited through the equivalent nodes - assert( pNode->fMark1 == 0 ); - // mark the node as visited - pNode->fMark1 = 1; - // add the node to the list - Map_NodeVecPush( vNodes, pNode ); -} - - - -/**Function************************************************************* - - Synopsis [Computes the number of logic levels not counting PIs/POs.] - - Description [] - - SideEffects [Note that this procedure will reassign the levels assigned - originally by NodeCreate() because it counts the number of levels with - choices differently!] - - SeeAlso [] - -***********************************************************************/ -int Map_MappingCountLevels( Map_Man_t * pMan ) -{ - int i, LevelsMax, LevelsCur; - // perform the traversal - LevelsMax = -1; - for ( i = 0; i < pMan->nOutputs; i++ ) - { - LevelsCur = Map_MappingCountLevels_rec( Map_Regular(pMan->pOutputs[i]) ); - if ( LevelsMax < LevelsCur ) - LevelsMax = LevelsCur; - } - for ( i = 0; i < pMan->nOutputs; i++ ) - Map_MappingUnmark_rec( Map_Regular(pMan->pOutputs[i]) ); - return LevelsMax; -} - -/**Function************************************************************* - - Synopsis [Recursively computes the number of logic levels.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_MappingCountLevels_rec( Map_Node_t * pNode ) -{ - int Level1, Level2; - assert( !Map_IsComplement(pNode) ); - if ( !Map_NodeIsAnd(pNode) ) - { - pNode->Level = 0; - return 0; - } - if ( pNode->fMark0 ) - return pNode->Level; - pNode->fMark0 = 1; - // visit the transitive fanin - Level1 = Map_MappingCountLevels_rec( Map_Regular(pNode->p1) ); - Level2 = Map_MappingCountLevels_rec( Map_Regular(pNode->p2) ); - // set the number of levels - pNode->Level = 1 + ((Level1>Level2)? Level1: Level2); - return pNode->Level; -} - -/**Function************************************************************* - - Synopsis [Unmarks the nodes.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingUnmark( Map_Man_t * pMan ) -{ - int i; - for ( i = 0; i < pMan->nOutputs; i++ ) - Map_MappingUnmark_rec( Map_Regular(pMan->pOutputs[i]) ); -} - -/**Function************************************************************* - - Synopsis [Recursively unmarks the nodes.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingUnmark_rec( Map_Node_t * pNode ) -{ - assert( !Map_IsComplement(pNode) ); - if ( pNode->fMark0 == 0 ) - return; - pNode->fMark0 = 0; - if ( !Map_NodeIsAnd(pNode) ) - return; - Map_MappingUnmark_rec( Map_Regular(pNode->p1) ); - Map_MappingUnmark_rec( Map_Regular(pNode->p2) ); - // visit the equivalent nodes - if ( pNode->pNextE ) - Map_MappingUnmark_rec( pNode->pNextE ); -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingMark_rec( Map_Node_t * pNode ) -{ - assert( !Map_IsComplement(pNode) ); - if ( pNode->fMark0 == 1 ) - return; - pNode->fMark0 = 1; - if ( !Map_NodeIsAnd(pNode) ) - return; - // visit the transitive fanin of the selected cut - Map_MappingMark_rec( Map_Regular(pNode->p1) ); - Map_MappingMark_rec( Map_Regular(pNode->p2) ); -} - -/**Function************************************************************* - - Synopsis [Compares the outputs by their arrival times.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_MappingCompareOutputDelay( Map_Node_t ** ppNode1, Map_Node_t ** ppNode2 ) -{ - Map_Node_t * pNode1 = Map_Regular(*ppNode1); - Map_Node_t * pNode2 = Map_Regular(*ppNode2); - int fPhase1 = !Map_IsComplement(*ppNode1); - int fPhase2 = !Map_IsComplement(*ppNode2); - float Arrival1 = pNode1->tArrival[fPhase1].Worst; - float Arrival2 = pNode2->tArrival[fPhase2].Worst; - if ( Arrival1 < Arrival2 ) - return -1; - if ( Arrival1 > Arrival2 ) - return 1; - return 0; -} - -/**Function************************************************************* - - Synopsis [Finds given number of latest arriving COs.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingFindLatest( Map_Man_t * p, int * pNodes, int nNodesMax ) -{ - int nNodes, i, k, v; - assert( p->nOutputs >= nNodesMax ); - pNodes[0] = 0; - nNodes = 1; - for ( i = 1; i < p->nOutputs; i++ ) - { - for ( k = nNodes - 1; k >= 0; k-- ) - if ( Map_MappingCompareOutputDelay( &p->pOutputs[pNodes[k]], &p->pOutputs[i] ) >= 0 ) - break; - if ( k == nNodesMax - 1 ) - continue; - if ( nNodes < nNodesMax ) - nNodes++; - for ( v = nNodes - 1; v > k+1; v-- ) - pNodes[v] = pNodes[v-1]; - pNodes[k+1] = i; - } -} - -/**Function************************************************************* - - Synopsis [Prints a bunch of latest arriving outputs.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingPrintOutputArrivals( Map_Man_t * p ) -{ - int pSorted[MAP_CO_LIST_SIZE]; - Map_Time_t * pTimes; - Map_Node_t * pNode; - int fPhase, Limit, i; - int MaxNameSize; - - // determine the number of nodes to print - Limit = (p->nOutputs > MAP_CO_LIST_SIZE)? MAP_CO_LIST_SIZE : p->nOutputs; - - // determine the order - Map_MappingFindLatest( p, pSorted, Limit ); - - // determine max size of the node's name - MaxNameSize = 0; - for ( i = 0; i < Limit; i++ ) - if ( MaxNameSize < (int)strlen(p->ppOutputNames[pSorted[i]]) ) - MaxNameSize = strlen(p->ppOutputNames[pSorted[i]]); - - // print the latest outputs - for ( i = 0; i < Limit; i++ ) - { - // get the i-th latest output - pNode = Map_Regular(p->pOutputs[pSorted[i]]); - fPhase =!Map_IsComplement(p->pOutputs[pSorted[i]]); - pTimes = pNode->tArrival + fPhase; - // print out the best arrival time - printf( "Output %-*s : ", MaxNameSize + 3, p->ppOutputNames[pSorted[i]] ); - printf( "Delay = (%5.2f, %5.2f) ", (double)pTimes->Rise, (double)pTimes->Fall ); - printf( "%s", fPhase? "POS" : "NEG" ); - printf( "\n" ); - } -} - -/**Function************************************************************* - - Synopsis [Sets up the truth tables.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingSetupTruthTables( unsigned uTruths[][2] ) -{ - int m, v; - // set up the truth tables - for ( m = 0; m < 32; m++ ) - for ( v = 0; v < 5; v++ ) - if ( m & (1 << v) ) - uTruths[v][0] |= (1 << m); - // make adjustments for the case of 6 variables - for ( v = 0; v < 5; v++ ) - uTruths[v][1] = uTruths[v][0]; - uTruths[5][0] = 0; - uTruths[5][1] = MAP_FULL; -} - -/**Function************************************************************* - - Synopsis [Sets up the truth tables.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingSetupTruthTablesLarge( unsigned uTruths[][32] ) -{ - int m, v; - // clean everything - for ( m = 0; m < 32; m++ ) - for ( v = 0; v < 10; v++ ) - uTruths[v][m] = 0; - // set up the truth tables - for ( m = 0; m < 32; m++ ) - for ( v = 0; v < 5; v++ ) - if ( m & (1 << v) ) - { - uTruths[v][0] |= (1 << m); - uTruths[v+5][m] = MAP_FULL; - } - // extend this info for the rest of the first 5 variables - for ( m = 0; m < 32; m++ ) - for ( v = 0; v < 5; v++ ) - uTruths[v][m] = uTruths[v][0]; -/* - // verify - for ( m = 0; m < 1024; m++, printf("\n") ) - for ( v = 0; v < 10; v++ ) - if ( Map_InfoReadVar( uTruths[v], m ) ) - printf( "1" ); - else - printf( "0" ); -*/ -} - -/**Function************************************************************* - - Synopsis [Sets up the mask.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingSetupMask( unsigned uMask[], int nVarsMax ) -{ - if ( nVarsMax == 6 ) - uMask[0] = uMask[1] = MAP_FULL; - else - { - uMask[0] = MAP_MASK(1 << nVarsMax); - uMask[1] = 0; - } -} - -/**Function************************************************************* - - Synopsis [Verify one useful property.] - - Description [This procedure verifies one useful property. After - the FRAIG construction with choice nodes is over, each primary node - should have fanins that are primary nodes. The primary nodes is the - one that does not have pNode->pRepr set to point to another node.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_ManCheckConsistency( Map_Man_t * p ) -{ - Map_Node_t * pNode; - Map_NodeVec_t * pVec; - int i; - pVec = Map_MappingDfs( p, 0 ); - for ( i = 0; i < pVec->nSize; i++ ) - { - pNode = pVec->pArray[i]; - if ( Map_NodeIsVar(pNode) ) - { - if ( pNode->pRepr ) - printf( "Primary input %d is a secondary node.\n", pNode->Num ); - } - else if ( Map_NodeIsConst(pNode) ) - { - if ( pNode->pRepr ) - printf( "Constant 1 %d is a secondary node.\n", pNode->Num ); - } - else - { - if ( pNode->pRepr ) - printf( "Internal node %d is a secondary node.\n", pNode->Num ); - if ( Map_Regular(pNode->p1)->pRepr ) - printf( "Internal node %d has first fanin that is a secondary node.\n", pNode->Num ); - if ( Map_Regular(pNode->p2)->pRepr ) - printf( "Internal node %d has second fanin that is a secondary node.\n", pNode->Num ); - } - } - Map_NodeVecFree( pVec ); - return 1; -} - -/**Function************************************************************* - - Synopsis [Returns 1 if current mapping of the node violates fanout limits.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_MappingNodeIsViolator( Map_Node_t * pNode, Map_Cut_t * pCut, int fPosPol ) -{ - return pNode->nRefAct[fPosPol] > (int)pCut->M[fPosPol].pSuperBest->nFanLimit; -} - -/**Function************************************************************* - - Synopsis [Computes the total are flow of the network.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -float Map_MappingGetAreaFlow( Map_Man_t * p ) -{ - Map_Node_t * pNode; - Map_Cut_t * pCut; - float aFlowFlowTotal = 0; - int fPosPol, i; - for ( i = 0; i < p->nOutputs; i++ ) - { - pNode = Map_Regular(p->pOutputs[i]); - if ( !Map_NodeIsAnd(pNode) ) - continue; - fPosPol = !Map_IsComplement(p->pOutputs[i]); - pCut = pNode->pCutBest[fPosPol]; - if ( pCut == NULL ) - { - fPosPol = !fPosPol; - pCut = pNode->pCutBest[fPosPol]; - } - aFlowFlowTotal += pNode->pCutBest[fPosPol]->M[fPosPol].AreaFlow; - } - return aFlowFlowTotal; -} - - -/**Function************************************************************* - - Synopsis [Compares the supergates by their level.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_CompareNodesByLevel( Map_Node_t ** ppS1, Map_Node_t ** ppS2 ) -{ - Map_Node_t * pN1 = Map_Regular(*ppS1); - Map_Node_t * pN2 = Map_Regular(*ppS2); - if ( pN1->Level > pN2->Level ) - return -1; - if ( pN1->Level < pN2->Level ) - return 1; - return 0; -} - -/**Function************************************************************* - - Synopsis [Orders the nodes in the decreasing order of levels.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingSortByLevel( Map_Man_t * pMan, Map_NodeVec_t * vNodes ) -{ - qsort( (void *)vNodes->pArray, vNodes->nSize, sizeof(Map_Node_t *), - (int (*)(const void *, const void *)) Map_CompareNodesByLevel ); -// assert( Map_CompareNodesByLevel( vNodes->pArray, vNodes->pArray + vNodes->nSize - 1 ) <= 0 ); -} - - -/**Function************************************************************* - - Synopsis [Compares the supergates by their pointer.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_CompareNodesByPointer( Map_Node_t ** ppS1, Map_Node_t ** ppS2 ) -{ - if ( *ppS1 < *ppS2 ) - return -1; - if ( *ppS1 > *ppS2 ) - return 1; - return 0; -} - -/**Function************************************************************* - - Synopsis [Counts how many AIG nodes are mapped in both polarities.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_MappingCountDoubles( Map_Man_t * pMan, Map_NodeVec_t * vNodes ) -{ - Map_Node_t * pNode; - int Counter, i; - // count the number of equal adjacent nodes - Counter = 0; - for ( i = 0; i < vNodes->nSize; i++ ) - { - pNode = vNodes->pArray[i]; - if ( !Map_NodeIsAnd(pNode) ) - continue; - if ( (pNode->nRefAct[0] && pNode->pCutBest[0]) && - (pNode->nRefAct[1] && pNode->pCutBest[1]) ) - Counter++; - } - return Counter; -} - - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -st_table * Map_CreateTableGate2Super( Map_Man_t * pMan ) -{ - Map_Super_t * pSuper; - st_table * tTable; - int i, nInputs, v; - tTable = st_init_table(strcmp, st_strhash); - for ( i = 0; i < pMan->pSuperLib->nSupersAll; i++ ) - { - pSuper = pMan->pSuperLib->ppSupers[i]; - if ( pSuper->nGates == 1 ) - { - // skip different versions of the same root gate - nInputs = Mio_GateReadInputs(pSuper->pRoot); - for ( v = 0; v < nInputs; v++ ) - if ( pSuper->pFanins[v]->Num != nInputs - 1 - v ) - break; - if ( v != nInputs ) - continue; -// printf( "%s\n", Mio_GateReadName(pSuper->pRoot) ); - if ( st_insert( tTable, (char *)pSuper->pRoot, (char *)pSuper ) ) - { - assert( 0 ); - } - } - } - return tTable; -} - -/**Function************************************************************* - - Synopsis [Get the FRAIG node with phase.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_ManCleanData( Map_Man_t * p ) -{ - int i; - for ( i = 0; i < p->vNodesAll->nSize; i++ ) - p->vNodesAll->pArray[i]->pData0 = p->vNodesAll->pArray[i]->pData1 = 0; -} - -/**Function************************************************************* - - Synopsis [Expand the truth table] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingExpandTruth( unsigned uTruth[2], int nVars ) -{ - assert( nVars < 7 ); - if ( nVars == 6 ) - return; - if ( nVars < 5 ) - { - uTruth[0] &= MAP_MASK( (1<vAnds->nSize; i++ ) - { - // skip primary inputs - pNode = p->vAnds->pArray[i]; - if ( !Map_NodeIsAnd( pNode ) ) - continue; - // skip a secondary node - if ( pNode->pRepr ) - continue; - // count the switching nodes - if ( pNode->nRefAct[0] > 0 ) - Map_TimeCutComputeArrival( pNode, pNode->pCutBest[0], 0, MAP_FLOAT_LARGE ); - if ( pNode->nRefAct[1] > 0 ) - Map_TimeCutComputeArrival( pNode, pNode->pCutBest[1], 1, MAP_FLOAT_LARGE ); - } - Result = Map_TimeComputeArrivalMax(p); - printf( "Max arrival times with fanouts = %10.2f.\n", Result ); - return Result; -} - - -/**Function************************************************************* - - Synopsis [Sets up the mask.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_MappingGetMaxLevel( Map_Man_t * pMan ) -{ - int nLevelMax, i; - nLevelMax = 0; - for ( i = 0; i < pMan->nOutputs; i++ ) - nLevelMax = ((unsigned)nLevelMax) > Map_Regular(pMan->pOutputs[i])->Level? - nLevelMax : Map_Regular(pMan->pOutputs[i])->Level; - return nLevelMax; -} - -/**Function************************************************************* - - Synopsis [Analyses choice nodes.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_MappingUpdateLevel_rec( Map_Man_t * pMan, Map_Node_t * pNode, int fMaximum ) -{ - Map_Node_t * pTemp; - int Level1, Level2, LevelE; - assert( !Map_IsComplement(pNode) ); - if ( !Map_NodeIsAnd(pNode) ) - return pNode->Level; - // skip the visited node - if ( pNode->TravId == pMan->nTravIds ) - return pNode->Level; - pNode->TravId = pMan->nTravIds; - // compute levels of the children nodes - Level1 = Map_MappingUpdateLevel_rec( pMan, Map_Regular(pNode->p1), fMaximum ); - Level2 = Map_MappingUpdateLevel_rec( pMan, Map_Regular(pNode->p2), fMaximum ); - pNode->Level = 1 + MAP_MAX( Level1, Level2 ); - if ( pNode->pNextE ) - { - LevelE = Map_MappingUpdateLevel_rec( pMan, pNode->pNextE, fMaximum ); - if ( fMaximum ) - { - if ( pNode->Level < (unsigned)LevelE ) - pNode->Level = LevelE; - } - else - { - if ( pNode->Level > (unsigned)LevelE ) - pNode->Level = LevelE; - } - // set the level of all equivalent nodes to be the same minimum - if ( pNode->pRepr == NULL ) // the primary node - for ( pTemp = pNode->pNextE; pTemp; pTemp = pTemp->pNextE ) - pTemp->Level = pNode->Level; - } - return pNode->Level; -} - -/**Function************************************************************* - - Synopsis [Resets the levels of the nodes in the choice graph.] - - Description [Makes the level of the choice nodes to be equal to the - maximum of the level of the nodes in the equivalence class. This way - sorting by level leads to the reverse topological order, which is - needed for the required time computation.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingSetChoiceLevels( Map_Man_t * pMan ) -{ - int i; - pMan->nTravIds++; - for ( i = 0; i < pMan->nOutputs; i++ ) - Map_MappingUpdateLevel_rec( pMan, Map_Regular(pMan->pOutputs[i]), 1 ); -} - -/**Function************************************************************* - - Synopsis [Reports statistics on choice nodes.] - - Description [The number of choice nodes is the number of primary nodes, - which has pNextE set to a pointer. The number of choices is the number - of entries in the equivalent-node lists of the primary nodes.] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingReportChoices( Map_Man_t * pMan ) -{ - Map_Node_t * pNode, * pTemp; - int nChoiceNodes, nChoices; - int i, LevelMax1, LevelMax2; - - // report the number of levels - LevelMax1 = Map_MappingGetMaxLevel( pMan ); - pMan->nTravIds++; - for ( i = 0; i < pMan->nOutputs; i++ ) - Map_MappingUpdateLevel_rec( pMan, Map_Regular(pMan->pOutputs[i]), 0 ); - LevelMax2 = Map_MappingGetMaxLevel( pMan ); - - // report statistics about choices - nChoiceNodes = nChoices = 0; - for ( i = 0; i < pMan->vAnds->nSize; i++ ) - { - pNode = pMan->vAnds->pArray[i]; - if ( pNode->pRepr == NULL && pNode->pNextE != NULL ) - { // this is a choice node = the primary node that has equivalent nodes - nChoiceNodes++; - for ( pTemp = pNode; pTemp; pTemp = pTemp->pNextE ) - nChoices++; - } - } - printf( "Maximum level: Original = %d. Reduced due to choices = %d.\n", LevelMax1, LevelMax2 ); - printf( "Choice stats: Choice nodes = %d. Total choices = %d.\n", nChoiceNodes, nChoices ); -} - -/**Function************************************************************* - - Synopsis [Computes the maximum and minimum levels of the choice nodes.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_MappingGetChoiceLevels( Map_Man_t * pMan, Map_Node_t * p1, Map_Node_t * p2, int * pMin, int * pMax ) -{ - Map_NodeVec_t * vNodes; - Map_NodeVec_t * vBoundary; - Map_Node_t * pNode; - int i, Min, Max; - - vNodes = Map_NodeVecAlloc( 100 ); - vBoundary = Map_NodeVecAlloc( 100 ); - Map_MappingDfsMarked1_rec( p1, vNodes, 1 ); - Map_MappingDfsMarked2_rec( p2, vNodes, vBoundary, 1 ); - // clean the marks - Min = 100000; - Max = -100000; - for ( i = 0; i < vBoundary->nSize; i++ ) - { - pNode = vBoundary->pArray[i]; - if ( Min > (int)pNode->Level ) - Min = pNode->Level; - if ( Max < (int)pNode->Level ) - Max = pNode->Level; - } - Map_NodeVecFree( vBoundary ); - for ( i = 0; i < vNodes->nSize; i++ ) - { - pNode = vNodes->pArray[i]; - pNode->fMark0 = pNode->fMark1 = 0; - } - Map_NodeVecFree( vNodes ); - *pMin = Min; - *pMax = Max; -} - - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -float Map_MappingGetChoiceVolumes( Map_Man_t * pMan, Map_Node_t * p1, Map_Node_t * p2 ) -{ - Map_NodeVec_t * vNodes; - Map_Node_t * pNode; - int i, nVolumeTotal, nVolumeUnique; - - vNodes = Map_NodeVecAlloc( 100 ); - Map_MappingDfsMarked3_rec( p1, vNodes ); - Map_MappingDfsMarked4_rec( p2, vNodes ); - // clean the marks - nVolumeTotal = nVolumeUnique = 0; - for ( i = 0; i < vNodes->nSize; i++ ) - { - pNode = vNodes->pArray[i]; - if ( !Map_NodeIsAnd(pNode) ) - continue; - nVolumeTotal++; - if ( pNode->fMark0 ^ pNode->fMark1 ) - nVolumeUnique++; - pNode->fMark0 = pNode->fMark1 = 0; - } - Map_NodeVecFree( vNodes ); -// return ((float)nVolumeUnique)/nVolumeTotal; - return (float)nVolumeUnique; -} - - -/**Function************************************************************* - - Synopsis [Computes the maximum and minimum levels of the choice nodes.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_MappingCountUsedNodes( Map_Man_t * pMan, int fChoices ) -{ - Map_NodeVec_t * vNodes; - int Result; - vNodes = Map_MappingDfs( pMan, fChoices ); - Result = vNodes->nSize; - Map_NodeVecFree( vNodes ); - return Result; -} - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - - diff --git a/src/map/mapper/mapperVec.c b/src/map/mapper/mapperVec.c deleted file mode 100644 index f75138fb..00000000 --- a/src/map/mapper/mapperVec.c +++ /dev/null @@ -1,318 +0,0 @@ -/**CFile**************************************************************** - - FileName [mapperVec.c] - - PackageName [MVSIS 1.3: Multi-valued logic synthesis system.] - - Synopsis [Generic technology mapping engine.] - - Author [MVSIS Group] - - Affiliation [UC Berkeley] - - Date [Ver. 2.0. Started - June 1, 2004.] - - Revision [$Id: mapperVec.c,v 1.3 2005/01/23 06:59:45 alanmi Exp $] - -***********************************************************************/ - -#include "mapperInt.h" - -//////////////////////////////////////////////////////////////////////// -/// DECLARATIONS /// -//////////////////////////////////////////////////////////////////////// - -static int Map_NodeVecCompareLevels( Map_Node_t ** pp1, Map_Node_t ** pp2 ); - -//////////////////////////////////////////////////////////////////////// -/// FUNCTION DEFINITIONS /// -//////////////////////////////////////////////////////////////////////// - -/**Function************************************************************* - - Synopsis [Allocates a vector with the given capacity.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_NodeVec_t * Map_NodeVecAlloc( int nCap ) -{ - Map_NodeVec_t * p; - p = ALLOC( Map_NodeVec_t, 1 ); - if ( nCap > 0 && nCap < 16 ) - nCap = 16; - p->nSize = 0; - p->nCap = nCap; - p->pArray = p->nCap? ALLOC( Map_Node_t *, p->nCap ) : NULL; - return p; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_NodeVecFree( Map_NodeVec_t * p ) -{ - FREE( p->pArray ); - FREE( p ); -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Node_t ** Map_NodeVecReadArray( Map_NodeVec_t * p ) -{ - return p->pArray; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_NodeVecReadSize( Map_NodeVec_t * p ) -{ - return p->nSize; -} - -/**Function************************************************************* - - Synopsis [Resizes the vector to the given capacity.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_NodeVecGrow( Map_NodeVec_t * p, int nCapMin ) -{ - if ( p->nCap >= nCapMin ) - return; - p->pArray = REALLOC( Map_Node_t *, p->pArray, nCapMin ); - p->nCap = nCapMin; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_NodeVecShrink( Map_NodeVec_t * p, int nSizeNew ) -{ - assert( p->nSize >= nSizeNew ); - p->nSize = nSizeNew; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_NodeVecClear( Map_NodeVec_t * p ) -{ - p->nSize = 0; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_NodeVecPush( Map_NodeVec_t * p, Map_Node_t * Entry ) -{ - if ( p->nSize == p->nCap ) - { - if ( p->nCap < 16 ) - Map_NodeVecGrow( p, 16 ); - else - Map_NodeVecGrow( p, 2 * p->nCap ); - } - p->pArray[p->nSize++] = Entry; -} - -/**Function************************************************************* - - Synopsis [Add the element while ensuring uniqueness.] - - Description [Returns 1 if the element was found, and 0 if it was new. ] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_NodeVecPushUnique( Map_NodeVec_t * p, Map_Node_t * Entry ) -{ - int i; - for ( i = 0; i < p->nSize; i++ ) - if ( p->pArray[i] == Entry ) - return 1; - Map_NodeVecPush( p, Entry ); - return 0; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Node_t * Map_NodeVecPop( Map_NodeVec_t * p ) -{ - return p->pArray[--p->nSize]; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_NodeVecRemove( Map_NodeVec_t * p, Map_Node_t * Entry ) -{ - int i; - for ( i = 0; i < p->nSize; i++ ) - if ( p->pArray[i] == Entry ) - break; - assert( i < p->nSize ); - for ( i++; i < p->nSize; i++ ) - p->pArray[i-1] = p->pArray[i]; - p->nSize--; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_NodeVecWriteEntry( Map_NodeVec_t * p, int i, Map_Node_t * Entry ) -{ - assert( i >= 0 && i < p->nSize ); - p->pArray[i] = Entry; -} - -/**Function************************************************************* - - Synopsis [] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -Map_Node_t * Map_NodeVecReadEntry( Map_NodeVec_t * p, int i ) -{ - assert( i >= 0 && i < p->nSize ); - return p->pArray[i]; -} - -/**Function************************************************************* - - Synopsis [Sorting the entries by their integer value.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -void Map_NodeVecSortByLevel( Map_NodeVec_t * p ) -{ - qsort( (void *)p->pArray, p->nSize, sizeof(Map_Node_t *), - (int (*)(const void *, const void *)) Map_NodeVecCompareLevels ); -} - -/**Function************************************************************* - - Synopsis [Comparison procedure for two clauses.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ -int Map_NodeVecCompareLevels( Map_Node_t ** pp1, Map_Node_t ** pp2 ) -{ - int Level1 = Map_Regular(*pp1)->Level; - int Level2 = Map_Regular(*pp2)->Level; - if ( Level1 < Level2 ) - return -1; - if ( Level1 > Level2 ) - return 1; - if ( Map_Regular(*pp1)->Num < Map_Regular(*pp2)->Num ) - return -1; - if ( Map_Regular(*pp1)->Num > Map_Regular(*pp2)->Num ) - return 1; - return 0; -} - -//////////////////////////////////////////////////////////////////////// -/// END OF FILE /// -//////////////////////////////////////////////////////////////////////// - diff --git a/src/map/mapper/module.make b/src/map/mapper/module.make deleted file mode 100644 index bd6447d8..00000000 --- a/src/map/mapper/module.make +++ /dev/null @@ -1,18 +0,0 @@ -SRC += src/map/mapper/mapper.c \ - src/map/mapper/mapperCanon.c \ - src/map/mapper/mapperCore.c \ - src/map/mapper/mapperCreate.c \ - src/map/mapper/mapperCut.c \ - src/map/mapper/mapperCutUtils.c \ - src/map/mapper/mapperFanout.c \ - src/map/mapper/mapperLib.c \ - src/map/mapper/mapperMatch.c \ - src/map/mapper/mapperRefs.c \ - src/map/mapper/mapperSuper.c \ - src/map/mapper/mapperSwitch.c \ - src/map/mapper/mapperTable.c \ - src/map/mapper/mapperTime.c \ - src/map/mapper/mapperTree.c \ - src/map/mapper/mapperTruth.c \ - src/map/mapper/mapperUtils.c \ - src/map/mapper/mapperVec.c -- cgit v1.2.3