avr/qmk/googletest - [no description]

diff options

author	Andy Getz <durandal@google.com>	2019-11-13 17:03:54 -0500
committer	Andy Getz <durandal@google.com>	2019-11-13 17:03:54 -0500
commit	f73898f3ffd4005de534edec1139387457d5853c (patch)
tree	6769863296ae62bff69bb4296596f70c9505a3ce /googlemock/test/gmock-actions_test.cc
parent	11440f27c66da2ace6ec908a6081b23d230e09b8 (diff)
parent	f9665846e405664bec650d77f9dd236c61a293b0 (diff)
download	googletest-f73898f3ffd4005de534edec1139387457d5853c.tar.gz googletest-f73898f3ffd4005de534edec1139387457d5853c.tar.bz2 googletest-f73898f3ffd4005de534edec1139387457d5853c.zip

Merge pull request #2554 from kuzkry:update-gen_gtest_pred_impl

PiperOrigin-RevId: 279734102

Diffstat (limited to 'googlemock/test/gmock-actions_test.cc')

0 files changed, 0 insertions, 0 deletions

/**CFile**************************************************************** FileName [abcBalance.c] SystemName [ABC: Logic synthesis and verification system.] PackageName [Network and node package.] Synopsis [Performs global balancing of the AIG by the number of levels.] Author [Alan Mishchenko] Affiliation [UC Berkeley] Date [Ver. 1.0. Started - June 20, 2005.] Revision [$Id: abcBalance.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] ***********************************************************************/ #include "base/abc/abc.h" ABC_NAMESPACE_IMPL_START //////////////////////////////////////////////////////////////////////// /// DECLARATIONS /// //////////////////////////////////////////////////////////////////////// static void Abc_NtkBalancePerform( Abc_Ntk_t * pNtk, Abc_Ntk_t * pNtkAig, int fDuplicate, int fSelective, int fUpdateLevel ); static Abc_Obj_t * Abc_NodeBalance_rec( Abc_Ntk_t * pNtkNew, Abc_Obj_t * pNode, Vec_Vec_t * vStorage, int Level, int fDuplicate, int fSelective, int fUpdateLevel ); static Vec_Ptr_t * Abc_NodeBalanceCone( Abc_Obj_t * pNode, Vec_Vec_t * vSuper, int Level, int fDuplicate, int fSelective ); static int Abc_NodeBalanceCone_rec( Abc_Obj_t * pNode, Vec_Ptr_t * vSuper, int fFirst, int fDuplicate, int fSelective ); static void Abc_NtkMarkCriticalNodes( Abc_Ntk_t * pNtk ); static Vec_Ptr_t * Abc_NodeBalanceConeExor( Abc_Obj_t * pNode ); //////////////////////////////////////////////////////////////////////// /// FUNCTION DEFINITIONS /// //////////////////////////////////////////////////////////////////////// /**Function************************************************************* Synopsis [Balances the AIG network.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Abc_Ntk_t * Abc_NtkBalance( Abc_Ntk_t * pNtk, int fDuplicate, int fSelective, int fUpdateLevel ) { // extern void Abc_NtkHaigTranfer( Abc_Ntk_t * pNtkOld, Abc_Ntk_t * pNtkNew ); Abc_Ntk_t * pNtkAig; assert( Abc_NtkIsStrash(pNtk) ); // compute the required times if ( fSelective ) { Abc_NtkStartReverseLevels( pNtk, 0 ); Abc_NtkMarkCriticalNodes( pNtk ); } // perform balancing pNtkAig = Abc_NtkStartFrom( pNtk, ABC_NTK_STRASH, ABC_FUNC_AIG ); // transfer HAIG // Abc_NtkHaigTranfer( pNtk, pNtkAig ); // perform balancing Abc_NtkBalancePerform( pNtk, pNtkAig, fDuplicate, fSelective, fUpdateLevel ); Abc_NtkFinalize( pNtk, pNtkAig ); Abc_AigCleanup( (Abc_Aig_t *)pNtkAig->pManFunc ); // undo the required times if ( fSelective ) { Abc_NtkStopReverseLevels( pNtk ); Abc_NtkCleanMarkA( pNtk ); } if ( pNtk->pExdc ) pNtkAig->pExdc = Abc_NtkDup( pNtk->pExdc ); // make sure everything is okay if ( !Abc_NtkCheck( pNtkAig ) ) { printf( "Abc_NtkBalance: The network check has failed.\n" ); Abc_NtkDelete( pNtkAig ); return NULL; } //Abc_NtkPrintCiLevels( pNtkAig ); return pNtkAig; } /**Function************************************************************* Synopsis [Balances the AIG network.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ void Abc_NtkBalancePerform( Abc_Ntk_t * pNtk, Abc_Ntk_t * pNtkAig, int fDuplicate, int fSelective, int fUpdateLevel ) { ProgressBar * pProgress; Vec_Vec_t * vStorage; Abc_Obj_t * pNode; int i; // transfer level Abc_NtkForEachCi( pNtk, pNode, i ) pNode->pCopy->Level = pNode->Level; // set the level of PIs of AIG according to the arrival times of the old network Abc_NtkSetNodeLevelsArrival( pNtk ); // allocate temporary storage for supergates vStorage = Vec_VecStart( 10 ); // perform balancing of POs pProgress = Extra_ProgressBarStart( stdout, Abc_NtkCoNum(pNtk) ); if ( pNtk->nBarBufs == 0 ) { Abc_NtkForEachCo( pNtk, pNode, i ) { Extra_ProgressBarUpdate( pProgress, i, NULL ); Abc_NodeBalance_rec( pNtkAig, Abc_ObjFanin0(pNode), vStorage, 0, fDuplicate, fSelective, fUpdateLevel ); } } else { Abc_NtkForEachLiPo( pNtk, pNode, i ) { Extra_ProgressBarUpdate( pProgress, i, NULL ); Abc_NodeBalance_rec( pNtkAig, Abc_ObjFanin0(pNode), vStorage, 0, fDuplicate, fSelective, fUpdateLevel ); if ( i < pNtk->nBarBufs ) Abc_ObjFanout0(Abc_ObjFanout0(pNode))->Level = Abc_ObjFanin0(pNode)->Level; } } Extra_ProgressBarStop( pProgress ); Vec_VecFree( vStorage ); } /**Function************************************************************* Synopsis [Finds the left bound on the next candidate to be paired.] Description [The nodes in the array are in the decreasing order of levels. The last node in the array has the smallest level. By default it would be paired with the next node on the left. However, it may be possible to pair it with some other node on the left, in such a way that the new node is shared. This procedure finds the index of the left-most node, which can be paired with the last node.] SideEffects [] SeeAlso [] ***********************************************************************/ int Abc_NodeBalanceFindLeft( Vec_Ptr_t * vSuper ) { Abc_Obj_t * pNodeRight, * pNodeLeft; int Current; // if two or less nodes, pair with the first if ( Vec_PtrSize(vSuper) < 3 ) return 0; // set the pointer to the one before the last Current = Vec_PtrSize(vSuper) - 2; pNodeRight = (Abc_Obj_t *)Vec_PtrEntry( vSuper, Current ); // go through the nodes to the left of this one for ( Current--; Current >= 0; Current-- ) { // get the next node on the left pNodeLeft = (Abc_Obj_t *)Vec_PtrEntry( vSuper, Current ); // if the level of this node is different, quit the loop if ( Abc_ObjRegular(pNodeLeft)->Level != Abc_ObjRegular(pNodeRight)->Level ) break; } Current++; // get the node, for which the equality holds pNodeLeft = (Abc_Obj_t *)Vec_PtrEntry( vSuper, Current ); assert( Abc_ObjRegular(pNodeLeft)->Level == Abc_ObjRegular(pNodeRight)->Level ); return Current; } /**Function************************************************************* Synopsis [Moves closer to the end the node that is best for sharing.] Description [If there is no node with sharing, randomly chooses one of the legal nodes.] SideEffects [] SeeAlso [] ***********************************************************************/ void Abc_NodeBalancePermute( Abc_Ntk_t * pNtkNew, Vec_Ptr_t * vSuper, int LeftBound ) { Abc_Obj_t * pNode1, * pNode2, * pNode3; int RightBound, i; // get the right bound RightBound = Vec_PtrSize(vSuper) - 2; assert( LeftBound <= RightBound ); if ( LeftBound == RightBound ) return; // get the two last nodes pNode1 = (Abc_Obj_t *)Vec_PtrEntry( vSuper, RightBound + 1 ); pNode2 = (Abc_Obj_t *)Vec_PtrEntry( vSuper, RightBound ); // find the first node that can be shared for ( i = RightBound; i >= LeftBound; i-- ) { pNode3 = (Abc_Obj_t *)Vec_PtrEntry( vSuper, i ); if ( Abc_AigAndLookup( (Abc_Aig_t *)pNtkNew->pManFunc, pNode1, pNode3 ) ) { if ( pNode3 == pNode2 ) return; Vec_PtrWriteEntry( vSuper, i, pNode2 ); Vec_PtrWriteEntry( vSuper, RightBound, pNode3 ); return; } } /* // we did not find the node to share, randomize choice { int Choice = rand() % (RightBound - LeftBound + 1); pNode3 = Vec_PtrEntry( vSuper, LeftBound + Choice ); if ( pNode3 == pNode2 ) return; Vec_PtrWriteEntry( vSuper, LeftBound + Choice, pNode2 ); Vec_PtrWriteEntry( vSuper, RightBound, pNode3 ); } */ } /**Function************************************************************* Synopsis [Rebalances the multi-input node rooted at pNodeOld.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Abc_Obj_t * Abc_NodeBalance_rec( Abc_Ntk_t * pNtkNew, Abc_Obj_t * pNodeOld, Vec_Vec_t * vStorage, int Level, int fDuplicate, int fSelective, int fUpdateLevel ) { Abc_Aig_t * pMan = (Abc_Aig_t *)pNtkNew->pManFunc; Abc_Obj_t * pNodeNew, * pNode1, * pNode2; Vec_Ptr_t * vSuper; int i, LeftBound; assert( !Abc_ObjIsComplement(pNodeOld) ); // return if the result if known if ( pNodeOld->pCopy ) return pNodeOld->pCopy; assert( Abc_ObjIsNode(pNodeOld) ); // get the implication supergate // Abc_NodeBalanceConeExor( pNodeOld ); vSuper = Abc_NodeBalanceCone( pNodeOld, vStorage, Level, fDuplicate, fSelective ); if ( vSuper->nSize == 0 ) { // it means that the supergate contains two nodes in the opposite polarity pNodeOld->pCopy = Abc_ObjNot(Abc_AigConst1(pNtkNew)); return pNodeOld->pCopy; } // for each old node, derive the new well-balanced node for ( i = 0; i < vSuper->nSize; i++ ) { pNodeNew = Abc_NodeBalance_rec( pNtkNew, Abc_ObjRegular((Abc_Obj_t *)vSuper->pArray[i]), vStorage, Level + 1, fDuplicate, fSelective, fUpdateLevel ); vSuper->pArray[i] = Abc_ObjNotCond( pNodeNew, Abc_ObjIsComplement((Abc_Obj_t *)vSuper->pArray[i]) ); } if ( vSuper->nSize < 2 ) printf( "BUG!\n" ); // sort the new nodes by level in the decreasing order Vec_PtrSort( vSuper, (int (*)(void))Abc_NodeCompareLevelsDecrease ); // balance the nodes assert( vSuper->nSize > 1 ); while ( vSuper->nSize > 1 ) { // find the left bound on the node to be paired LeftBound = (!fUpdateLevel)? 0 : Abc_NodeBalanceFindLeft( vSuper ); // find the node that can be shared (if no such node, randomize choice) Abc_NodeBalancePermute( pNtkNew, vSuper, LeftBound ); // pull out the last two nodes pNode1 = (Abc_Obj_t *)Vec_PtrPop(vSuper); pNode2 = (Abc_Obj_t *)Vec_PtrPop(vSuper); Abc_VecObjPushUniqueOrderByLevel( vSuper, Abc_AigAnd(pMan, pNode1, pNode2) ); } // make sure the balanced node is not assigned assert( pNodeOld->pCopy == NULL ); // mark the old node with the new node pNodeOld->pCopy = (Abc_Obj_t *)vSuper->pArray[0]; vSuper->nSize = 0; // if ( Abc_ObjRegular(pNodeOld->pCopy) == Abc_AigConst1(pNtkNew) ) // printf( "Constant node\n" ); // assert( pNodeOld->Level >= Abc_ObjRegular(pNodeOld->pCopy)->Level ); return pNodeOld->pCopy; } /**Function************************************************************* Synopsis [Collects the nodes in the cone delimited by fMarkA==1.] Description [Returns -1 if the AND-cone has the same node in both polarities. Returns 1 if the AND-cone has the same node in the same polarity. Returns 0 if the AND-cone has no repeated nodes.] SideEffects [] SeeAlso [] ***********************************************************************/ Vec_Ptr_t * Abc_NodeBalanceCone( Abc_Obj_t * pNode, Vec_Vec_t * vStorage, int Level, int fDuplicate, int fSelective ) { Vec_Ptr_t * vNodes; int RetValue, i; assert( !Abc_ObjIsComplement(pNode) ); // extend the storage if ( Vec_VecSize( vStorage ) <= Level ) Vec_VecPush( vStorage, Level, 0 ); // get the temporary array of nodes vNodes = Vec_VecEntry( vStorage, Level ); Vec_PtrClear( vNodes ); // collect the nodes in the implication supergate RetValue = Abc_NodeBalanceCone_rec( pNode, vNodes, 1, fDuplicate, fSelective ); assert( vNodes->nSize > 1 ); // unmark the visited nodes for ( i = 0; i < vNodes->nSize; i++ ) Abc_ObjRegular((Abc_Obj_t *)vNodes->pArray[i])->fMarkB = 0; // if we found the node and its complement in the same implication supergate, // return empty set of nodes (meaning that we should use constant-0 node) if ( RetValue == -1 ) vNodes->nSize = 0; return vNodes; } /**Function************************************************************* Synopsis [Collects the nodes in the cone delimited by fMarkA==1.] Description [Returns -1 if the AND-cone has the same node in both polarities. Returns 1 if the AND-cone has the same node in the same polarity. Returns 0 if the AND-cone has no repeated nodes.] SideEffects [] SeeAlso [] ***********************************************************************/ int Abc_NodeBalanceCone_rec( Abc_Obj_t * pNode, Vec_Ptr_t * vSuper, int fFirst, int fDuplicate, int fSelective ) { int RetValue1, RetValue2, i; // check if the node is visited if ( Abc_ObjRegular(pNode)->fMarkB ) { // check if the node occurs in the same polarity for ( i = 0; i < vSuper->nSize; i++ ) if ( vSuper->pArray[i] == pNode ) return 1; // check if the node is present in the opposite polarity for ( i = 0; i < vSuper->nSize; i++ ) if ( vSuper->pArray[i] == Abc_ObjNot(pNode) ) return -1; assert( 0 ); return 0; } // if the new node is complemented or a PI, another gate begins if ( !fFirst && (Abc_ObjIsComplement(pNode) || !Abc_ObjIsNode(pNode) || (!fDuplicate && !fSelective && (Abc_ObjFanoutNum(pNode) > 1)) || Vec_PtrSize(vSuper) > 10000) ) { Vec_PtrPush( vSuper, pNode ); Abc_ObjRegular(pNode)->fMarkB = 1; return 0; } assert( !Abc_ObjIsComplement(pNode) ); assert( Abc_ObjIsNode(pNode) ); // go through the branches RetValue1 = Abc_NodeBalanceCone_rec( Abc_ObjChild0(pNode), vSuper, 0, fDuplicate, fSelective ); RetValue2 = Abc_NodeBalanceCone_rec( Abc_ObjChild1(pNode), vSuper, 0, fDuplicate, fSelective ); if ( RetValue1 == -1 || RetValue2 == -1 ) return -1; // return 1 if at least one branch has a duplicate return RetValue1 || RetValue2; } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ int Abc_NodeBalanceConeExor_rec( Abc_Obj_t * pNode, Vec_Ptr_t * vSuper, int fFirst ) { int RetValue1, RetValue2, i; // check if the node occurs in the same polarity for ( i = 0; i < vSuper->nSize; i++ ) if ( vSuper->pArray[i] == pNode ) return 1; // if the new node is complemented or a PI, another gate begins if ( !fFirst && (!pNode->fExor || !Abc_ObjIsNode(pNode)) ) { Vec_PtrPush( vSuper, pNode ); return 0; } assert( !Abc_ObjIsComplement(pNode) ); assert( Abc_ObjIsNode(pNode) ); assert( pNode->fExor ); // go through the branches RetValue1 = Abc_NodeBalanceConeExor_rec( Abc_ObjFanin0(Abc_ObjFanin0(pNode)), vSuper, 0 ); RetValue2 = Abc_NodeBalanceConeExor_rec( Abc_ObjFanin1(Abc_ObjFanin0(pNode)), vSuper, 0 ); if ( RetValue1 == -1 || RetValue2 == -1 ) return -1; // return 1 if at least one branch has a duplicate return RetValue1 || RetValue2; } /**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Vec_Ptr_t * Abc_NodeBalanceConeExor( Abc_Obj_t * pNode ) { Vec_Ptr_t * vSuper; if ( !pNode->fExor ) return NULL; vSuper = Vec_PtrAlloc( 10 ); Abc_NodeBalanceConeExor_rec( pNode, vSuper, 1 ); printf( "%d ", Vec_PtrSize(vSuper) ); Vec_PtrFree( vSuper ); return NULL; } /**Function************************************************************* Synopsis [Collects the nodes in the implication supergate.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Vec_Ptr_t * Abc_NodeFindCone_rec( Abc_Obj_t * pNode ) { Vec_Ptr_t * vNodes; Abc_Obj_t * pNodeC, * pNodeT, * pNodeE; int RetValue, i; assert( !Abc_ObjIsComplement(pNode) ); if ( Abc_ObjIsCi(pNode) ) return NULL; // start the new array vNodes = Vec_PtrAlloc( 4 ); // if the node is the MUX collect its fanins if ( Abc_NodeIsMuxType(pNode) ) { pNodeC = Abc_NodeRecognizeMux( pNode, &pNodeT, &pNodeE ); Vec_PtrPush( vNodes, Abc_ObjRegular(pNodeC) ); Vec_PtrPushUnique( vNodes, Abc_ObjRegular(pNodeT) ); Vec_PtrPushUnique( vNodes, Abc_ObjRegular(pNodeE) ); } else { // collect the nodes in the implication supergate RetValue = Abc_NodeBalanceCone_rec( pNode, vNodes, 1, 1, 0 ); assert( vNodes->nSize > 1 ); // unmark the visited nodes Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i ) Abc_ObjRegular(pNode)->fMarkB = 0; // if we found the node and its complement in the same implication supergate, // return empty set of nodes (meaning that we should use constant-0 node) if ( RetValue == -1 ) vNodes->nSize = 0; } // call for the fanin Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i ) { pNode = Abc_ObjRegular(pNode); if ( pNode->pCopy ) continue; pNode->pCopy = (Abc_Obj_t *)Abc_NodeFindCone_rec( pNode ); } return vNodes; } /**Function************************************************************* Synopsis [Attaches the implication supergates to internal nodes.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ void Abc_NtkBalanceAttach( Abc_Ntk_t * pNtk ) { Abc_Obj_t * pNode; int i; Abc_NtkCleanCopy( pNtk ); Abc_NtkForEachCo( pNtk, pNode, i ) { pNode = Abc_ObjFanin0(pNode); if ( pNode->pCopy ) continue; pNode->pCopy = (Abc_Obj_t *)Abc_NodeFindCone_rec( pNode ); } } /**Function************************************************************* Synopsis [Attaches the implication supergates to internal nodes.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ void Abc_NtkBalanceDetach( Abc_Ntk_t * pNtk ) { Abc_Obj_t * pNode; int i; Abc_NtkForEachNode( pNtk, pNode, i ) if ( pNode->pCopy ) { Vec_PtrFree( (Vec_Ptr_t *)pNode->pCopy ); pNode->pCopy = NULL; } } /**Function************************************************************* Synopsis [Compute levels of implication supergates.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ int Abc_NtkBalanceLevel_rec( Abc_Obj_t * pNode ) { Vec_Ptr_t * vSuper; Abc_Obj_t * pFanin; int i, LevelMax; assert( !Abc_ObjIsComplement(pNode) ); if ( pNode->Level > 0 ) return pNode->Level; if ( Abc_ObjIsCi(pNode) ) return 0; vSuper = (Vec_Ptr_t *)pNode->pCopy; assert( vSuper != NULL ); LevelMax = 0; Vec_PtrForEachEntry( Abc_Obj_t *, vSuper, pFanin, i ) { pFanin = Abc_ObjRegular(pFanin); Abc_NtkBalanceLevel_rec(pFanin); if ( LevelMax < (int)pFanin->Level ) LevelMax = pFanin->Level; } pNode->Level = LevelMax + 1; return pNode->Level; } /**Function************************************************************* Synopsis [Compute levels of implication supergates.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ void Abc_NtkBalanceLevel( Abc_Ntk_t * pNtk ) { Abc_Obj_t * pNode; int i; Abc_NtkForEachObj( pNtk, pNode, i ) pNode->Level = 0; Abc_NtkForEachCo( pNtk, pNode, i ) Abc_NtkBalanceLevel_rec( Abc_ObjFanin0(pNode) ); } /**Function************************************************************* Synopsis [Marks the nodes on the critical and near critical paths.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ void Abc_NtkMarkCriticalNodes( Abc_Ntk_t * pNtk ) { Abc_Obj_t * pNode; int i, Counter = 0; Abc_NtkForEachNode( pNtk, pNode, i ) if ( Abc_ObjRequiredLevel(pNode) - pNode->Level <= 1 ) pNode->fMarkA = 1, Counter++; printf( "The number of nodes on the critical paths = %6d (%5.2f %%)\n", Counter, 100.0 * Counter / Abc_NtkNodeNum(pNtk) ); } //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// ABC_NAMESPACE_IMPL_END


context:
space:
mode: