abc/src/misc/util/utilMem.c

/**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