summaryrefslogtreecommitdiffstats
path: root/src/misc/util/utilMem.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/misc/util/utilMem.c')
-rw-r--r--src/misc/util/utilMem.c341
1 files changed, 341 insertions, 0 deletions
diff --git a/src/misc/util/utilMem.c b/src/misc/util/utilMem.c
new file mode 100644
index 00000000..0bce119b
--- /dev/null
+++ b/src/misc/util/utilMem.c
@@ -0,0 +1,341 @@
+/**CFile****************************************************************
+
+ FileName [utilMem.c]
+
+ SystemName [ABC: Logic synthesis and verification system.]
+
+ PackageName [Memory recycling utilities.]
+
+ Synopsis [Memory recycling utilities.]
+
+ Author [Alan Mishchenko]
+
+ Affiliation [UC Berkeley]
+
+ Date [Ver. 1.0. Started - June 20, 2005.]
+
+ Revision [$Id: utilMem.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#include "abc_global.h"
+
+ABC_NAMESPACE_IMPL_START
+
+////////////////////////////////////////////////////////////////////////
+/// DECLARATIONS ///
+////////////////////////////////////////////////////////////////////////
+
+
+typedef struct Vec_Mem_t_ Vec_Mem_t;
+struct Vec_Mem_t_
+{
+ int nCap;
+ int nSize;
+ void ** pArray;
+};
+
+void * s_vAllocs = NULL;
+void * s_vFrees = NULL;
+int s_fInterrupt = 0;
+
+#define ABC_MEM_ALLOC(type, num) ((type *) malloc(sizeof(type) * (num)))
+#define ABC_MEM_CALLOC(type, num) ((type *) calloc((num), sizeof(type)))
+#define ABC_MEM_FALLOC(type, num) ((type *) memset(malloc(sizeof(type) * (num)), 0xff, sizeof(type) * (num)))
+#define ABC_MEM_FREE(obj) ((obj) ? (free((char *) (obj)), (obj) = 0) : 0)
+#define ABC_MEM_REALLOC(type, obj, num) \
+ ((obj) ? ((type *) realloc((char *)(obj), sizeof(type) * (num))) : \
+ ((type *) malloc(sizeof(type) * (num))))
+
+////////////////////////////////////////////////////////////////////////
+/// FUNCTION DEFINITIONS ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+ Synopsis [Allocates a vector with the given capacity.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+static inline Vec_Mem_t * Vec_MemAlloc( int nCap )
+{
+ Vec_Mem_t * p;
+ p = ABC_MEM_ALLOC( Vec_Mem_t, 1 );
+ if ( nCap > 0 && nCap < 8 )
+ nCap = 8;
+ p->nSize = 0;
+ p->nCap = nCap;
+ p->pArray = p->nCap? ABC_MEM_ALLOC( void *, p->nCap ) : NULL;
+ return p;
+}
+
+/**Function*************************************************************
+
+ Synopsis [Frees the vector.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+static inline void Vec_MemFree( Vec_Mem_t * p )
+{
+ ABC_MEM_FREE( p->pArray );
+ ABC_MEM_FREE( p );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Resizes the vector to the given capacity.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+static inline void Vec_MemGrow( Vec_Mem_t * p, int nCapMin )
+{
+ if ( p->nCap >= nCapMin )
+ return;
+ p->pArray = ABC_MEM_REALLOC( void *, p->pArray, nCapMin );
+ p->nCap = nCapMin;
+}
+
+/**Function*************************************************************
+
+ Synopsis []
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+static inline void Vec_MemPush( Vec_Mem_t * p, void * Entry )
+{
+ if ( p->nSize == p->nCap )
+ {
+ if ( p->nCap < 16 )
+ Vec_MemGrow( p, 16 );
+ else
+ Vec_MemGrow( p, 2 * p->nCap );
+ }
+ p->pArray[p->nSize++] = Entry;
+}
+
+/**Function*************************************************************
+
+ Synopsis [Sorting the entries by their integer value.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+static void Vec_MemSort( Vec_Mem_t * p, int (*Vec_MemSortCompare)() )
+{
+ if ( p->nSize < 2 )
+ return;
+ qsort( (void *)p->pArray, p->nSize, sizeof(void *),
+ (int (*)(const void *, const void *)) Vec_MemSortCompare );
+}
+
+
+/**Function*************************************************************
+
+ Synopsis [Remembers an allocated pointer.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void * Util_MemRecAlloc( void * pMem )
+{
+ if ( s_vAllocs )
+ Vec_MemPush( (Vec_Mem_t *)s_vAllocs, pMem );
+ return pMem;
+}
+
+/**Function*************************************************************
+
+ Synopsis [Remembers a deallocated pointer.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void * Util_MemRecFree( void * pMem )
+{
+ if ( s_vFrees )
+ Vec_MemPush( (Vec_Mem_t *)s_vFrees, pMem );
+ return pMem;
+}
+
+/**Function*************************************************************
+
+ Synopsis [Procedure used for sorting the nodes in decreasing order of levels.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+int Util_ComparePointers( void ** pp1, void ** pp2 )
+{
+ if ( *pp1 < *pp2 )
+ return -1;
+ if ( *pp1 > *pp2 )
+ return 1;
+ return 0;
+}
+
+/**Function*************************************************************
+
+ Synopsis [Finds entries that do not appear in both lists.]
+
+ Description [Assumes that the vectors are sorted in the increasing order.]
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+static inline Vec_Mem_t * Vec_MemTwoMerge( Vec_Mem_t * vArr1, Vec_Mem_t * vArr2 )
+{
+ Vec_Mem_t * vArr = Vec_MemAlloc( vArr1->nSize + vArr2->nSize );
+ void ** pBeg = vArr->pArray;
+ void ** pBeg1 = vArr1->pArray;
+ void ** pBeg2 = vArr2->pArray;
+ void ** pEnd1 = vArr1->pArray + vArr1->nSize;
+ void ** pEnd2 = vArr2->pArray + vArr2->nSize;
+ while ( pBeg1 < pEnd1 && pBeg2 < pEnd2 )
+ {
+ if ( *pBeg1 == *pBeg2 )
+ pBeg1++, pBeg2++;
+ else if ( *pBeg1 < *pBeg2 )
+ {
+ free( *pBeg1 );
+ *pBeg++ = *pBeg1++;
+ }
+ else
+ assert( 0 );
+// *pBeg++ = *pBeg2++;
+ }
+ while ( pBeg1 < pEnd1 )
+ *pBeg++ = *pBeg1++;
+// while ( pBeg2 < pEnd2 )
+// *pBeg++ = *pBeg2++;
+ assert( pBeg2 >= pEnd2 );
+ vArr->nSize = pBeg - vArr->pArray;
+ assert( vArr->nSize <= vArr->nCap );
+ assert( vArr->nSize >= vArr1->nSize );
+ assert( vArr->nSize >= vArr2->nSize );
+ return vArr;
+}
+
+/**Function*************************************************************
+
+ Synopsis [Recycles the accumulated memory.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Util_MemRecRecycle()
+{
+ Vec_Mem_t * vMerge;
+ assert( s_vAllocs == NULL );
+ assert( s_vFrees == NULL );
+ Vec_MemSort( (Vec_Mem_t *)s_vAllocs, (int (*)())Util_ComparePointers );
+ Vec_MemSort( (Vec_Mem_t *)s_vFrees, (int (*)())Util_ComparePointers );
+ vMerge = (Vec_Mem_t *)Vec_MemTwoMerge( (Vec_Mem_t *)s_vAllocs, (Vec_Mem_t *)s_vFrees );
+ Vec_MemFree( vMerge );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Starts memory structures.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Util_MemRecStart()
+{
+ assert( s_vAllocs == NULL && s_vFrees == NULL );
+ s_vAllocs = Vec_MemAlloc( 1000 );
+ s_vFrees = Vec_MemAlloc( 1000 );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Quits memory structures.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Util_MemRecQuit()
+{
+ assert( s_vAllocs != NULL && s_vFrees != NULL );
+ Vec_MemFree( (Vec_Mem_t *)s_vAllocs );
+ Vec_MemFree( (Vec_Mem_t *)s_vFrees );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Starts memory structures.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+int Util_MemRecIsSet()
+{
+ return s_vAllocs != NULL && s_vFrees != NULL;
+}
+
+////////////////////////////////////////////////////////////////////////
+/// END OF FILE ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-02 16:02:32 +0000