/**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 [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; }
/**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; }
ABC_NAMESPACE_IMPL_START //////////////////////////////////////////////////////////////////////// /// 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 = 0; int fUseAreaFlow = 1; int fUseExactArea = !p->fSwitching; int fUseExactAreaWithPhase = !p->fSwitching; abctime 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 = Abc_Clock(); Map_MappingCuts( p ); p->timeCuts = Abc_Clock() - clk; // derive the truth tables clk = Abc_Clock(); Map_MappingTruths( p ); p->timeTruth = Abc_Clock() - clk; ////////////////////////////////////////////////////////////////////// //ABC_PRT( "Truths", Abc_Clock() - clk ); ////////////////////////////////////////////////////////////////////// // compute the minimum-delay mapping clk = Abc_Clock(); p->fMappingMode = 0; if ( !Map_MappingMatches( p ) ) return 0; p->timeMatch = Abc_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 ); ABC_PRT( "Time", p->timeMatch ); } ////////////////////////////////////////////////////////////////////// if ( !p->fAreaRecovery ) { if ( p->fVerbose ) Map_MappingPrintOutputArrivals( p ); return 1; } ////////////////////////////////////////////////////////////////////// // perform area recovery using area flow clk = Abc_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 ); ABC_PRT( "Time", Abc_Clock() - clk ); } } p->timeArea += Abc_Clock() - clk; ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// // perform area recovery using exact area clk = Abc_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 ); ABC_PRT( "Time", Abc_Clock() - clk ); } } p->timeArea += Abc_Clock() - clk; ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// // perform area recovery using exact area clk = Abc_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 ); ABC_PRT( "Time", Abc_Clock() - clk ); } } p->timeArea += Abc_Clock() - clk; ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// // perform area recovery using exact area clk = Abc_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 ); ABC_PRT( "Time", Abc_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 ); ABC_PRT( "Time", Abc_Clock() - clk ); } } p->timeArea += Abc_Clock() - clk; ////////////////////////////////////////////////////////////////////// // print the arrival times of the latest outputs if ( p->fVerbose ) Map_MappingPrintOutputArrivals( p ); return 1; }