avr/qmk/googletest - [no description]

diff options

author	Abseil Team <absl-team@google.com>	2020-02-07 16:09:11 -0500
committer	Andy Getz <durandal@google.com>	2020-02-07 18:20:45 -0500
commit	41b5f149ab306e96b5b2faf523505d75acffd98a (patch)
tree	4277d57b73935ea47f80a5ad9b8e611f891c4051 /googlemock/scripts
parent	2d6d7a01c9ce9d7aded4106890ba2352e586c54a (diff)
download	googletest-41b5f149ab306e96b5b2faf523505d75acffd98a.tar.gz googletest-41b5f149ab306e96b5b2faf523505d75acffd98a.tar.bz2 googletest-41b5f149ab306e96b5b2faf523505d75acffd98a.zip

Googletest export

Get rid of gmock-generated-matchers.h and gmock-generated-matchers.h.pump. Stop using pump for MATCHER* macroses generation. PiperOrigin-RevId: 293878808

Diffstat (limited to 'googlemock/scripts')

0 files changed, 0 insertions, 0 deletions

/**CFile**************************************************************** FileName [dchClass.c] SystemName [ABC: Logic synthesis and verification system.] PackageName [Choice computation for tech-mapping.] Synopsis [Representation of candidate equivalence classes.] Author [Alan Mishchenko] Affiliation [UC Berkeley] Date [Ver. 1.0. Started - June 29, 2008.] Revision [$Id: dchClass.c,v 1.00 2008/07/29 00:00:00 alanmi Exp $] ***********************************************************************/ #include "dchInt.h" ABC_NAMESPACE_IMPL_START /* The candidate equivalence classes are stored as a vector of pointers to the array of pointers to the nodes in each class. The first node of the class is its representative node. The representative has the smallest topological order among the class nodes. The nodes inside each class are ordered according to their topological order. The classes are ordered according to the topo order of their representatives. */ // internal representation of candidate equivalence classes struct Dch_Cla_t_ { // class information Aig_Man_t * pAig; // original AIG manager Aig_Obj_t *** pId2Class; // non-const classes by ID of repr node int * pClassSizes; // sizes of each equivalence class // statistics int nClasses; // the total number of non-const classes int nCands1; // the total number of const candidates int nLits; // the number of literals in all classes // memory Aig_Obj_t ** pMemClasses; // memory allocated for equivalence classes Aig_Obj_t ** pMemClassesFree; // memory allocated for equivalence classes to be used // temporary data Vec_Ptr_t * vClassOld; // old equivalence class after splitting Vec_Ptr_t * vClassNew; // new equivalence class(es) after splitting // procedures used for class refinement void * pManData; unsigned (*pFuncNodeHash) (void *,Aig_Obj_t *); // returns hash key of the node int (*pFuncNodeIsConst) (void *,Aig_Obj_t *); // returns 1 if the node is a constant int (*pFuncNodesAreEqual) (void *,Aig_Obj_t *, Aig_Obj_t *); // returns 1 if nodes are equal up to a complement }; //////////////////////////////////////////////////////////////////////// /// DECLARATIONS /// //////////////////////////////////////////////////////////////////////// static inline Aig_Obj_t * Dch_ObjNext( Aig_Obj_t ** ppNexts, Aig_Obj_t * pObj ) { return ppNexts[pObj->Id]; } static inline void Dch_ObjSetNext( Aig_Obj_t ** ppNexts, Aig_Obj_t * pObj, Aig_Obj_t * pNext ) { ppNexts[pObj->Id] = pNext; } // iterator through the equivalence classes #define Dch_ManForEachClass( p, ppClass, i ) \ for ( i = 0; i < Aig_ManObjNumMax(p->pAig); i++ ) \ if ( ((ppClass) = p->pId2Class[i]) == NULL ) {} else // iterator through the nodes in one class #define Dch_ClassForEachNode( p, pRepr, pNode, i ) \ for ( i = 0; i < p->pClassSizes[pRepr->Id]; i++ ) \ if ( ((pNode) = p->pId2Class[pRepr->Id][i]) == NULL ) {} else //////////////////////////////////////////////////////////////////////// /// FUNCTION DEFINITIONS /// //////////////////////////////////////////////////////////////////////// /**Function************************************************************* Synopsis [Creates one equivalence class.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline void Dch_ObjAddClass( Dch_Cla_t * p, Aig_Obj_t * pRepr, Aig_Obj_t ** pClass, int nSize ) { assert( p->pId2Class[pRepr->Id] == NULL ); p->pId2Class[pRepr->Id] = pClass; assert( p->pClassSizes[pRepr->Id] == 0 ); assert( nSize > 1 ); p->pClassSizes[pRepr->Id] = nSize; p->nClasses++; p->nLits += nSize - 1; } /**Function************************************************************* Synopsis [Removes one equivalence class.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ static inline Aig_Obj_t ** Dch_ObjRemoveClass( Dch_Cla_t * p, Aig_Obj_t * pRepr ) { Aig_Obj_t ** pClass = p->pId2Class[pRepr->Id]; int nSize; assert( pClass != NULL ); p->pId2Class[pRepr->Id] = NULL; nSize = p->pClassSizes[pRepr->Id]; assert( nSize > 1 ); p->nClasses--; p->nLits -= nSize - 1; p->pClassSizes[pRepr->Id] = 0; return pClass; } /**Function************************************************************* Synopsis [Starts representation of equivalence classes.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Dch_Cla_t * Dch_ClassesStart( Aig_Man_t * pAig ) { Dch_Cla_t * p; p = ABC_ALLOC( Dch_Cla_t, 1 ); memset( p, 0, sizeof(Dch_Cla_t) ); p->pAig = pAig; p->pId2Class = ABC_CALLOC( Aig_Obj_t **, Aig_ManObjNumMax(pAig) ); p->pClassSizes = ABC_CALLOC( int, Aig_ManObjNumMax(pAig) ); p->vClassOld = Vec_PtrAlloc( 100 ); p->vClassNew = Vec_PtrAlloc( 100 ); assert( pAig->pReprs == NULL ); Aig_ManReprStart( pAig, Aig_ManObjNumMax(pAig) ); return p; } /**Function************************************************************* Synopsis [Starts representation of equivalence classes.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ void Dch_ClassesSetData( Dch_Cla_t * p, void * pManData, unsigned (*pFuncNodeHash)(void *,Aig_Obj_t *), // returns hash key of the node int (*pFuncNodeIsConst)(void *,Aig_Obj_t *), // returns 1 if the node is a constant int (*pFuncNodesAreEqual)(void *,Aig_Obj_t *, Aig_Obj_t *) ) // returns 1 if nodes are equal up to a complement { p->pManData = pManData; p->pFuncNodeHash = pFuncNodeHash; p->pFuncNodeIsConst = pFuncNodeIsConst; p->pFuncNodesAreEqual = pFuncNodesAreEqual; } /**Function************************************************************* Synopsis [Stop representation of equivalence classes.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ void Dch_ClassesStop( Dch_Cla_t * p ) { if ( p->vClassNew ) Vec_PtrFree( p->vClassNew ); if ( p->vClassOld ) Vec_PtrFree( p->vClassOld ); ABC_FREE( p->pId2Class ); ABC_FREE( p->pClassSizes ); ABC_FREE( p->pMemClasses ); ABC_FREE( p ); } /**Function************************************************************* Synopsis [Stop representation of equivalence classes.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ int Dch_ClassesLitNum( Dch_Cla_t * p ) { return p->nLits; } /**Function************************************************************* Synopsis [Stop representation of equivalence classes.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ Aig_Obj_t ** Dch_ClassesReadClass( Dch_Cla_t * p, Aig_Obj_t * pRepr, int * pnSize ) { assert( p->pId2Class[pRepr->Id] != NULL ); assert( p->pClassSizes[pRepr->Id] > 1 ); *pnSize = p->pClassSizes[pRepr->Id]; return p->pId2Class[pRepr->Id]; } /**Function************************************************************* Synopsis [Checks candidate equivalence classes.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ void Dch_ClassesCheck( Dch_Cla_t * p ) { Aig_Obj_t * pObj, * pPrev, ** ppClass; int i, k, nLits, nClasses, nCands1; nClasses = nLits = 0; Dch_ManForEachClass( p, ppClass, k ) { pPrev = NULL; Dch_ClassForEachNode( p, ppClass[0], pObj, i ) { if ( i == 0 ) assert( Aig_ObjRepr(p->pAig, pObj) == NULL ); else { assert( Aig_ObjRepr(p->pAig, pObj) == ppClass[0] ); assert( pPrev->Id < pObj->Id ); nLits++; } pPrev = pObj; } nClasses++; } nCands1 = 0; Aig_ManForEachObj( p->pAig, pObj, i ) nCands1 += Dch_ObjIsConst1Cand( p->pAig, pObj ); assert( p->nLits == nLits ); assert( p->nCands1 == nCands1 ); assert( p->nClasses == nClasses ); } /**Function************************************************************* Synopsis [Prints simulation classes.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ void Dch_ClassesPrintOne( Dch_Cla_t * p, Aig_Obj_t * pRepr ) { Aig_Obj_t * pObj; int i; Abc_Print( 1, "{ " ); Dch_ClassForEachNode( p, pRepr, pObj, i ) Abc_Print( 1, "%d(%d,%d) ", pObj->Id, pObj->Level, Aig_SupportSize(p->pAig,pObj) ); Abc_Print( 1, "}\n" ); } /**Function************************************************************* Synopsis [Prints simulation classes.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ void Dch_ClassesPrint( Dch_Cla_t * p, int fVeryVerbose ) { Aig_Obj_t ** ppClass; Aig_Obj_t * pObj; int i; Abc_Print( 1, "Equivalence classes: Const1 = %5d. Class = %5d. Lit = %5d.\n", p->nCands1, p->nClasses, p->nLits ); if ( !fVeryVerbose ) return; Abc_Print( 1, "Constants { " ); Aig_ManForEachObj( p->pAig, pObj, i ) if ( Dch_ObjIsConst1Cand( p->pAig, pObj ) ) Abc_Print( 1, "%d(%d,%d) ", pObj->Id, pObj->Level, Aig_SupportSize(p->pAig,pObj) ); Abc_Print( 1, "}\n" ); Dch_ManForEachClass( p, ppClass, i ) { Abc_Print( 1, "%3d (%3d) : ", i, p->pClassSizes[i] ); Dch_ClassesPrintOne( p, ppClass[0] ); } Abc_Print( 1, "\n" ); } /**Function************************************************************* Synopsis [Creates initial simulation classes.] Description [Assumes that simulation info is assigned.] SideEffects [] SeeAlso [] ***********************************************************************/ void Dch_ClassesPrepare( Dch_Cla_t * p, int fLatchCorr, int nMaxLevs ) { Aig_Obj_t ** ppTable, ** ppNexts, ** ppClassNew; Aig_Obj_t * pObj, * pTemp, * pRepr; int i, k, nTableSize, nNodes, iEntry, nEntries, nEntries2; // allocate the hash table hashing simulation info into nodes nTableSize = Abc_PrimeCudd( Aig_ManObjNumMax(p->pAig)/4 ); ppTable = ABC_CALLOC( Aig_Obj_t *, nTableSize ); ppNexts = ABC_CALLOC( Aig_Obj_t *, Aig_ManObjNumMax(p->pAig) ); // add all the nodes to the hash table nEntries = 0; Aig_ManForEachObj( p->pAig, pObj, i ) { if ( fLatchCorr ) { if ( !Aig_ObjIsCi(pObj) ) continue; } else { if ( !Aig_ObjIsNode(pObj) && !Aig_ObjIsCi(pObj) ) continue; // skip the node with more that the given number of levels if ( nMaxLevs && (int)pObj->Level >= nMaxLevs ) continue; } // check if the node belongs to the class of constant 1 if ( p->pFuncNodeIsConst( p->pManData, pObj ) ) { Dch_ObjSetConst1Cand( p->pAig, pObj ); p->nCands1++; continue; } // hash the node by its simulation info iEntry = p->pFuncNodeHash( p->pManData, pObj ) % nTableSize; // add the node to the class if ( ppTable[iEntry] == NULL ) ppTable[iEntry] = pObj; else { // set the representative of this node pRepr = ppTable[iEntry]; Aig_ObjSetRepr( p->pAig, pObj, pRepr ); // add node to the table if ( Dch_ObjNext( ppNexts, pRepr ) == NULL ) { // this will be the second entry p->pClassSizes[pRepr->Id]++; nEntries++; } // add the entry to the list Dch_ObjSetNext( ppNexts, pObj, Dch_ObjNext( ppNexts, pRepr ) ); Dch_ObjSetNext( ppNexts, pRepr, pObj ); p->pClassSizes[pRepr->Id]++; nEntries++; } } // allocate room for classes p->pMemClasses = ABC_ALLOC( Aig_Obj_t *, nEntries + p->nCands1 ); p->pMemClassesFree = p->pMemClasses + nEntries; // copy the entries into storage in the topological order nEntries2 = 0; Aig_ManForEachObj( p->pAig, pObj, i ) { if ( !Aig_ObjIsNode(pObj) && !Aig_ObjIsCi(pObj) ) continue; nNodes = p->pClassSizes[pObj->Id]; // skip the nodes that are not representatives of non-trivial classes if ( nNodes == 0 ) continue; assert( nNodes > 1 ); // add the nodes to the class in the topological order ppClassNew = p->pMemClasses + nEntries2; ppClassNew[0] = pObj; for ( pTemp = Dch_ObjNext(ppNexts, pObj), k = 1; pTemp; pTemp = Dch_ObjNext(ppNexts, pTemp), k++ ) { ppClassNew[nNodes-k] = pTemp; } // add the class of nodes p->pClassSizes[pObj->Id] = 0; Dch_ObjAddClass( p, pObj, ppClassNew, nNodes ); // increment the number of entries nEntries2 += nNodes; } assert( nEntries == nEntries2 ); ABC_FREE( ppTable ); ABC_FREE( ppNexts ); // now it is time to refine the classes Dch_ClassesRefine( p ); Dch_ClassesCheck( p ); } /**Function************************************************************* Synopsis [Iteratively refines the classes after simulation.] Description [Returns the number of refinements performed.] SideEffects [] SeeAlso [] ***********************************************************************/ int Dch_ClassesRefineOneClass( Dch_Cla_t * p, Aig_Obj_t * pReprOld, int fRecursive ) { Aig_Obj_t ** pClassOld, ** pClassNew; Aig_Obj_t * pObj, * pReprNew; int i; // split the class Vec_PtrClear( p->vClassOld ); Vec_PtrClear( p->vClassNew ); Dch_ClassForEachNode( p, pReprOld, pObj, i ) if ( p->pFuncNodesAreEqual(p->pManData, pReprOld, pObj) ) Vec_PtrPush( p->vClassOld, pObj ); else Vec_PtrPush( p->vClassNew, pObj ); // check if splitting happened if ( Vec_PtrSize(p->vClassNew) == 0 ) return 0; // get the new representative pReprNew = (Aig_Obj_t *)Vec_PtrEntry( p->vClassNew, 0 ); assert( Vec_PtrSize(p->vClassOld) > 0 ); assert( Vec_PtrSize(p->vClassNew) > 0 ); // create old class pClassOld = Dch_ObjRemoveClass( p, pReprOld ); Vec_PtrForEachEntry( Aig_Obj_t *, p->vClassOld, pObj, i ) { pClassOld[i] = pObj; Aig_ObjSetRepr( p->pAig, pObj, i? pReprOld : NULL ); } // create new class pClassNew = pClassOld + i; Vec_PtrForEachEntry( Aig_Obj_t *, p->vClassNew, pObj, i ) { pClassNew[i] = pObj; Aig_ObjSetRepr( p->pAig, pObj, i? pReprNew : NULL ); } // put classes back if ( Vec_PtrSize(p->vClassOld) > 1 ) Dch_ObjAddClass( p, pReprOld, pClassOld, Vec_PtrSize(p->vClassOld) ); if ( Vec_PtrSize(p->vClassNew) > 1 ) Dch_ObjAddClass( p, pReprNew, pClassNew, Vec_PtrSize(p->vClassNew) ); // check if the class should be recursively refined if ( fRecursive && Vec_PtrSize(p->vClassNew) > 1 ) return 1 + Dch_ClassesRefineOneClass( p, pReprNew, 1 ); return 1; } /**Function************************************************************* Synopsis [Refines the classes after simulation.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ int Dch_ClassesRefine( Dch_Cla_t * p ) { Aig_Obj_t ** ppClass; int i, nRefis = 0; Dch_ManForEachClass( p, ppClass, i ) nRefis += Dch_ClassesRefineOneClass( p, ppClass[0], 0 ); return nRefis; } /**Function************************************************************* Synopsis [Returns equivalence class of the given node.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ void Dch_ClassesCollectOneClass( Dch_Cla_t * p, Aig_Obj_t * pRepr, Vec_Ptr_t * vRoots ) { Aig_Obj_t * pObj; int i; Vec_PtrClear( vRoots ); Dch_ClassForEachNode( p, pRepr, pObj, i ) Vec_PtrPush( vRoots, pObj ); assert( Vec_PtrSize(vRoots) > 1 ); } /**Function************************************************************* Synopsis [Returns equivalence class of the given node.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ void Dch_ClassesCollectConst1Group( Dch_Cla_t * p, Aig_Obj_t * pObj, int nNodes, Vec_Ptr_t * vRoots ) { int i, Limit; Vec_PtrClear( vRoots ); Limit = Abc_MinInt( pObj->Id + nNodes, Aig_ManObjNumMax(p->pAig) ); for ( i = pObj->Id; i < Limit; i++ ) { pObj = Aig_ManObj( p->pAig, i ); if ( pObj && Dch_ObjIsConst1Cand( p->pAig, pObj ) ) Vec_PtrPush( vRoots, pObj ); } } /**Function************************************************************* Synopsis [Refine the group of constant 1 nodes.] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ int Dch_ClassesRefineConst1Group( Dch_Cla_t * p, Vec_Ptr_t * vRoots, int fRecursive )


context:
space:
mode: