Cumulative changes of the last two weeks.

src/misc/extra/extra.h

@@ -196,6 +196,8 @@ extern DdNode *     Extra_bddCreateExor( DdManager * dd, int nVars );
 extern DdNode *     Extra_zddPrimes( DdManager * dd, DdNode * F );
 extern void         Extra_bddPermuteArray( DdManager * dd, DdNode ** bNodesIn, DdNode ** bNodesOut, int nNodes, int *permut );
 extern DdNode *     Extra_bddComputeCube( DdManager * dd, DdNode ** bXVars, int nVars );
+extern DdNode *     Extra_bddChangePolarity( DdManager * dd, DdNode * bFunc, DdNode * bVars );
+extern DdNode *     extraBddChangePolarity( DdManager * dd, DdNode * bFunc, DdNode * bVars );
 
 #ifndef ABC_PRB
 #define ABC_PRB(dd,f)       printf("%s = ", #f); Extra_bddPrint(dd,f); printf("\n")

src/misc/extra/extraBddMisc.c

@@ -1013,6 +1013,32 @@ DdNode * Extra_bddComputeCube( DdManager * dd, DdNode ** bXVars, int nVars )
     return bRes;
 }
 
+/**Function********************************************************************
+
+  Synopsis    [Changes the polarity of vars listed in the cube.]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * Extra_bddChangePolarity( 
+  DdManager * dd,   /* the DD manager */
+  DdNode * bFunc,
+  DdNode * bVars) 
+{
+    DdNode  *res;
+    do {
+        dd->reordered = 0;
+        res = extraBddChangePolarity( dd, bFunc, bVars );
+    } while (dd->reordered == 1);
+    return(res);
+
+} /* end of Extra_bddChangePolarity */
+
+
 /*---------------------------------------------------------------------------*/
 /* Definition of internal functions                                          */
 /*---------------------------------------------------------------------------*/
@@ -1659,6 +1685,121 @@ cuddBddPermuteRecur( DdManager * manager /* DD manager */ ,
 }                                /* end of cuddBddPermuteRecur */
 
 
+/**Function********************************************************************
+
+  Synopsis    [Performs the reordering-sensitive step of Extra_bddChangePolarity().]
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+******************************************************************************/
+DdNode * extraBddChangePolarity( 
+  DdManager * dd,    /* the DD manager */
+  DdNode * bFunc, 
+  DdNode * bVars) 
+{
+    DdNode * bRes;
+
+    if ( bVars == b1 )
+        return bFunc;
+    if ( Cudd_IsConstant(bFunc) )
+        return bFunc;
+
+    if ( bRes = cuddCacheLookup2(dd, extraBddChangePolarity, bFunc, bVars) )
+        return bRes;
+    else
+    {
+        DdNode * bFR = Cudd_Regular(bFunc); 
+        int LevelF   = dd->perm[bFR->index];
+        int LevelV   = dd->perm[bVars->index];
+
+        if ( LevelV < LevelF )
+            bRes = extraBddChangePolarity( dd, bFunc, cuddT(bVars) );
+        else // if ( LevelF <= LevelV )
+        {
+            DdNode * bRes0, * bRes1;             
+            DdNode * bF0, * bF1;             
+            DdNode * bVarsNext;
+
+            // cofactor the functions
+            if ( bFR != bFunc ) // bFunc is complemented 
+            {
+                bF0 = Cudd_Not( cuddE(bFR) );
+                bF1 = Cudd_Not( cuddT(bFR) );
+            }
+            else
+            {
+                bF0 = cuddE(bFR);
+                bF1 = cuddT(bFR);
+            }
+
+            if ( LevelF == LevelV )
+                bVarsNext = cuddT(bVars);
+            else
+                bVarsNext = bVars;
+
+            bRes0 = extraBddChangePolarity( dd, bF0, bVarsNext );
+            if ( bRes0 == NULL ) 
+                return NULL;
+            cuddRef( bRes0 );
+
+            bRes1 = extraBddChangePolarity( dd, bF1, bVarsNext );
+            if ( bRes1 == NULL ) 
+            {
+                Cudd_RecursiveDeref( dd, bRes0 );
+                return NULL;
+            }
+            cuddRef( bRes1 );
+
+            if ( LevelF == LevelV )
+            { // swap the cofactors
+                DdNode * bTemp;
+                bTemp = bRes0;
+                bRes0 = bRes1;
+                bRes1 = bTemp;
+            }
+
+            /* only aRes0 and aRes1 are referenced at this point */
+
+            /* consider the case when Res0 and Res1 are the same node */
+            if ( bRes0 == bRes1 )
+                bRes = bRes1;
+            /* consider the case when Res1 is complemented */
+            else if ( Cudd_IsComplement(bRes1) ) 
+            {
+                bRes = cuddUniqueInter(dd, bFR->index, Cudd_Not(bRes1), Cudd_Not(bRes0));
+                if ( bRes == NULL ) 
+                {
+                    Cudd_RecursiveDeref(dd,bRes0);
+                    Cudd_RecursiveDeref(dd,bRes1);
+                    return NULL;
+                }
+                bRes = Cudd_Not(bRes);
+            } 
+            else 
+            {
+                bRes = cuddUniqueInter( dd, bFR->index, bRes1, bRes0 );
+                if ( bRes == NULL ) 
+                {
+                    Cudd_RecursiveDeref(dd,bRes0);
+                    Cudd_RecursiveDeref(dd,bRes1);
+                    return NULL;
+                }
+            }
+            cuddDeref( bRes0 );
+            cuddDeref( bRes1 );
+        }
+            
+        /* insert the result into cache */
+        cuddCacheInsert2(dd, extraBddChangePolarity, bFunc, bVars, bRes);
+        return bRes;
+    }
+} /* end of extraBddChangePolarity */
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////

src/misc/hash/hashFlt.h

@@ -311,14 +311,15 @@ static inline void Hash_FltRemove( Hash_Flt_t *p, int key )
 ***********************************************************************/
 static inline void Hash_FltFree( Hash_Flt_t *p ) {
   int bin;
-  Hash_Flt_Entry_t *pEntry;
+  Hash_Flt_Entry_t *pEntry, *pTemp;
 
   // free bins
   for(bin = 0; bin < p->nBins; bin++) {
     pEntry = p->pArray[bin];
     while(pEntry) {
+      pTemp = pEntry;
       pEntry = pEntry->pNext;
-      ABC_FREE( pEntry );
+      ABC_FREE( pTemp );
     }
   }
  

src/misc/hash/hashGen.h

@@ -0,0 +1,360 @@
+/**CFile****************************************************************
+
+  FileName    [vecGen.h]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [Hash maps.]
+
+  Synopsis    [Hash maps.]
+
+  Author      [Aaron P. Hurst, Alan Mishchenko]
+  
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - Jan 26, 2011.]
+
+  Revision    [$Id: vecGen.h,v 1.00 2005/06/20 00:00:00 ahurst Exp $]
+
+***********************************************************************/
+ 
+#ifndef __HASH_GEN_H__
+#define __HASH_GEN_H__
+
+
+////////////////////////////////////////////////////////////////////////
+///                          INCLUDES                                ///
+////////////////////////////////////////////////////////////////////////
+
+#include <stdio.h>
+#include "extra.h"
+
+ABC_NAMESPACE_HEADER_START
+
+
+////////////////////////////////////////////////////////////////////////
+///                         PARAMETERS                               ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+///                         BASIC TYPES                              ///
+////////////////////////////////////////////////////////////////////////
+
+typedef struct Hash_Gen_t_       Hash_Gen_t;
+typedef struct Hash_Gen_Entry_t_ Hash_Gen_Entry_t;
+
+struct Hash_Gen_Entry_t_
+{
+  char *                          key;
+  void *                          data;
+  struct Hash_Gen_Entry_t_ *     pNext;
+};
+
+struct Hash_Gen_t_ 
+{
+  int                             nSize;
+  int                             nBins;
+  int (* fHash)(void * key, int nBins);
+  int (* fComp)(void * key, void * key);
+  Hash_Gen_Entry_t **            pArray;
+};
+
+
+
+////////////////////////////////////////////////////////////////////////
+///                      MACRO DEFINITIONS                           ///
+////////////////////////////////////////////////////////////////////////
+
+#define Hash_GenForEachEntry( pHash, pEntry, bin )   \
+  for(bin=-1, pEntry=NULL; bin < pHash->nBins; (!pEntry)?(pEntry=pHash->pArray[++bin]):(pEntry=pEntry->pNext)) \
+    if (pEntry)
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Default hash function for strings.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static int Hash_DefaultHashFuncStr( void * key, int nBins )
+{
+    int i, Value = 0;
+    if ( key[0] == 0 )
+        return 0;
+    for ( i = strlen(key)-1; i >= 0; i-- )
+        Value = 5 * Value + key[i];
+    return Value % nBins;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Allocates a hash map with the given number of bins.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline Hash_Gen_t * Hash_GenAlloc( 
+  int nBins, 
+  int (*Hash_FuncHash)(void *, int), 
+  int (*Hash_FuncComp)(void *, void *) )
+{
+  Hash_Gen_t * p;
+  int i;
+  assert(nBins > 0);
+  p = ABC_CALLOC( Hash_Gen_t, 1 );
+  p->nBins  = nBins;
+  p->fHash  = Hash_FuncHash? Hash_FuncHash : (int (*)(void *, int))Hash_DefaultHashFuncStr;
+  p->fComp  = Hash_FuncComp? Hash_FuncComp : (int (*)(void *, void *))strcmp;
+  p->nSize  = 0;
+  p->pArray = ABC_CALLOC( Hash_Gen_Entry_t *, nBins );
+  return p;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Returns 1 if a key already exists.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline int Hash_GenExists( Hash_Gen_t *p, void * key )
+{
+  int bin;
+  Hash_Gen_Entry_t *pEntry;
+
+  // find the bin where this key would live
+  bin = (*(p->fHash))(key, p->nBins);
+
+  // search for key
+  pEntry = p->pArray[bin];
+  while(pEntry) {
+    if ( !p->fComp(pEntry->key,key) ) {
+      return 1;
+    }
+    pEntry = pEntry->pNext;
+  }
+
+  return 0;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Finds or creates an entry with a key and writes value.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Hash_GenWriteEntry( Hash_Gen_t *p, void * key, void * data )
+{
+  int bin;
+  Hash_Gen_Entry_t *pEntry, **pLast;
+
+  // find the bin where this key would live
+  bin = (*(p->fHash))(key, p->nBins);
+
+  // search for key
+  pLast = &(p->pArray[bin]);
+  pEntry = p->pArray[bin];
+  while(pEntry) {
+    if ( !p->fComp(pEntry->key,key) ) {
+      pEntry->data = data;
+      return;
+    }
+    pLast = &(pEntry->pNext);
+    pEntry = pEntry->pNext;
+  }
+
+  // this key does not currently exist
+  // create a new entry and add to bin
+  p->nSize++;
+  (*pLast) = pEntry = ABC_ALLOC( Hash_Gen_Entry_t, 1 );
+  pEntry->pNext = NULL;
+  pEntry->key  = key;
+  pEntry->data = data;
+
+  return;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Finds or creates an entry with a key.]
+
+  Description [fCreate specifies whether a new entry should be created.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void * Hash_GenEntry( Hash_Gen_t *p, void * key, int fCreate )
+{
+  int bin;
+  Hash_Gen_Entry_t *pEntry, **pLast;
+
+  // find the bin where this key would live
+  bin = (*(p->fHash))(key, p->nBins);
+
+  // search for key
+  pLast = &(p->pArray[bin]);
+  pEntry = p->pArray[bin];
+  while(pEntry) {
+    if ( !p->fComp(pEntry->key,key) )
+      return pEntry->data;
+    pLast = &(pEntry->pNext);
+    pEntry = pEntry->pNext;
+  }
+
+  // this key does not currently exist
+  if (fCreate) {
+    // create a new entry and add to bin
+    p->nSize++;
+    (*pLast) = pEntry = ABC_ALLOC( Hash_Gen_Entry_t, 1 );
+    pEntry->pNext = NULL;
+    pEntry->key  = key;
+    pEntry->data = NULL;
+    return pEntry->data;
+  }
+
+  return NULL;
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    [Finds or creates an entry with a key and returns the pointer to it.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void** Hash_GenEntryPtr( Hash_Gen_t *p, void * key )
+{
+  int bin;
+  Hash_Gen_Entry_t *pEntry, **pLast;
+
+  // find the bin where this key would live
+  bin = (*(p->fHash))(key, p->nBins);
+
+  // search for key
+  pLast = &(p->pArray[bin]);
+  pEntry = p->pArray[bin];
+  while(pEntry) {
+    if ( !p->fComp(pEntry->key,key) )
+      return &(pEntry->data);
+    pLast = &(pEntry->pNext);
+    pEntry = pEntry->pNext;
+  }
+
+  // this key does not currently exist
+  // create a new entry and add to bin
+  p->nSize++;
+  (*pLast) = pEntry = ABC_ALLOC( Hash_Gen_Entry_t, 1 );
+  pEntry->pNext = NULL;
+  pEntry->key  = key;
+  pEntry->data = NULL;
+
+  return &(pEntry->data);
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Deletes an entry.]
+
+  Description [Returns data, if there was any.]
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void* Hash_GenRemove( Hash_Gen_t *p, void * key )
+{
+  int    bin;
+  void * data;
+  Hash_Gen_Entry_t *pEntry, **pLast;
+
+  // find the bin where this key would live
+  bin = (*(p->fHash))(key, p->nBins);
+
+  // search for key
+  pLast = &(p->pArray[bin]);
+  pEntry = p->pArray[bin];
+  while(pEntry) {
+    if ( !p->fComp(pEntry->key,key) ) {
+      p->nSize--;
+      data = pEntry->data;
+      *pLast = pEntry->pNext;
+      return data;
+    }
+    pLast = &(pEntry->pNext);
+    pEntry = pEntry->pNext;
+  }
+    
+  // could not find key
+  return NULL;
+}
+
+/**Function*************************************************************
+
+  Synopsis    [Frees the hash.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+static inline void Hash_GenFree( Hash_Gen_t *p ) 
+{
+  int bin;
+  Hash_Gen_Entry_t *pEntry, *pTemp;
+
+  // free bins
+  for(bin = 0; bin < p->nBins; bin++) {
+    pEntry = p->pArray[bin];
+    while(pEntry) {
+      pTemp = pEntry;
+      pEntry = pEntry->pNext;
+      ABC_FREE( pTemp );
+    }
+  }
+ 
+  // free hash
+  ABC_FREE( p->pArray );
+  ABC_FREE( p );
+}
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+
+ABC_NAMESPACE_HEADER_END
+
+#endif

src/misc/hash/hashPtr.h

@@ -115,19 +115,17 @@ static inline Hash_Ptr_t * Hash_PtrAlloc( int nBins )
 static inline int Hash_PtrExists( Hash_Ptr_t *p, int key )
 {
   int bin;
-  Hash_Ptr_Entry_t *pEntry, **pLast;
+  Hash_Ptr_Entry_t *pEntry;
 
   // find the bin where this key would live
   bin = (*(p->fHash))(key, p->nBins);
 
   // search for key
-  pLast = &(p->pArray[bin]);
   pEntry = p->pArray[bin];
   while(pEntry) {
     if (pEntry->key == key) {
       return 1;
     }
-    pLast = &(pEntry->pNext);
     pEntry = pEntry->pNext;
   }
 
@@ -310,16 +308,18 @@ static inline void* Hash_PtrRemove( Hash_Ptr_t *p, int key )
   SeeAlso     []
 
 ***********************************************************************/
-static inline void Hash_PtrFree( Hash_Ptr_t *p ) {
+static inline void Hash_PtrFree( Hash_Ptr_t *p ) 
+{
   int bin;
-  Hash_Ptr_Entry_t *pEntry;
+  Hash_Ptr_Entry_t *pEntry, *pTemp;
 
   // free bins
   for(bin = 0; bin < p->nBins; bin++) {
     pEntry = p->pArray[bin];
     while(pEntry) {
+      pTemp = pEntry;
       pEntry = pEntry->pNext;
-      ABC_FREE( pEntry );
+      ABC_FREE( pTemp );
     }
   }