utilMem.c File Reference

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include "abc_global.h"

Go to the source code of this file.

Data Structures
struct	Vec_Mem_t_

Macros
#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)

Typedefs
typedef typedefABC_NAMESPACE_IMPL_START struct Vec_Mem_t_	Vec_Mem_t
	DECLARATIONS ///. More...

Functions
static Vec_Mem_t *	Vec_MemAlloc (int nCap)
	FUNCTION DEFINITIONS ///. More...
static void	Vec_MemFree (Vec_Mem_t *p)
static void	Vec_MemGrow (Vec_Mem_t *p, int nCapMin)
static void	Vec_MemPush (Vec_Mem_t *p, void *Entry)
static void	Vec_MemSort (Vec_Mem_t *p, int(*Vec_MemSortCompare)())
void *	Util_MemRecAlloc (void *pMem)
	BASIC TYPES ///. More...
void *	Util_MemRecFree (void *pMem)
int	Util_ComparePointers (void **pp1, void **pp2)
static Vec_Mem_t *	Vec_MemTwoMerge (Vec_Mem_t *vArr1, Vec_Mem_t *vArr2)
void	Util_MemRecRecycle ()
void	Util_MemRecStart ()
void	Util_MemRecQuit ()
int	Util_MemRecIsSet ()

Variables
void *	s_vAllocs = NULL
	INCLUDES ///. More...
void *	s_vFrees = NULL
int	s_fInterrupt = 0

Macro Definition Documentation

#define ABC_MEM_ALLOC	(		type,
			num
	)		((type *) malloc(sizeof(type) * (num)))

Definition at line 47 of file utilMem.c.

#define ABC_MEM_CALLOC	(		type,
			num
	)		((type *) calloc((num), sizeof(type)))

Definition at line 48 of file utilMem.c.

#define ABC_MEM_FALLOC	(		type,
			num
	)		((type *) memset(malloc(sizeof(type) * (num)), 0xff, sizeof(type) * (num)))

Definition at line 49 of file utilMem.c.

#define ABC_MEM_FREE

(

obj

)

((obj) ? (free((char *) (obj)), (obj) = 0) : 0)

Definition at line 50 of file utilMem.c.

#define ABC_MEM_REALLOC	(		type,
			obj,
			num
	)

Value:

((obj) ? ((type *) realloc((char *)(obj), sizeof(type) * (num))) : \
         ((type *) malloc(sizeof(type) * (num))))

Definition at line 51 of file utilMem.c.

Typedef Documentation

typedef typedefABC_NAMESPACE_IMPL_START struct Vec_Mem_t_ Vec_Mem_t

DECLARATIONS ///.

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

]

Definition at line 35 of file utilMem.c.

Function Documentation

int Util_ComparePointers	(	void **	pp1,
		void **	pp2
	)

Function*************************************************************

Synopsis [Procedure used for sorting the nodes in decreasing order of levels.]

Description []

SideEffects []

SeeAlso []

Definition at line 208 of file utilMem.c.

{
    if ( *pp1 < *pp2 )
        return -1;
    if ( *pp1 > *pp2 ) 
        return 1;
    return 0; 
}

void* Util_MemRecAlloc

(

void *

pMem

)

BASIC TYPES ///.

Function*************************************************************

Synopsis [Remembers an allocated pointer.]

Description []

SideEffects []

SeeAlso []

Definition at line 172 of file utilMem.c.

{
    if ( s_vAllocs )
        Vec_MemPush( (Vec_Mem_t *)s_vAllocs, pMem );
    return pMem;
}

void* Util_MemRecFree

(

void *

pMem

)

Function*************************************************************

Synopsis [Remembers a deallocated pointer.]

Description []

SideEffects []

SeeAlso []

Definition at line 190 of file utilMem.c.

{
    if ( s_vFrees )
        Vec_MemPush( (Vec_Mem_t *)s_vFrees, pMem );
    return pMem;
}

int Util_MemRecIsSet

(

)

Function*************************************************************

Synopsis [Starts memory structures.]

Description []

SideEffects []

SeeAlso []

Definition at line 330 of file utilMem.c.

{
    return s_vAllocs != NULL && s_vFrees != NULL;
}

void Util_MemRecQuit

(

)

Function*************************************************************

Synopsis [Quits memory structures.]

Description []

SideEffects []

SeeAlso []

Definition at line 312 of file utilMem.c.

{
    assert( s_vAllocs != NULL && s_vFrees != NULL );
    Vec_MemFree( (Vec_Mem_t *)s_vAllocs );
    Vec_MemFree( (Vec_Mem_t *)s_vFrees );
}

void Util_MemRecRecycle

(

)

Function*************************************************************

Synopsis [Recycles the accumulated memory.]

Description []

SideEffects []

SeeAlso []

Definition at line 272 of file utilMem.c.

{
    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 );
}

void Util_MemRecStart

(

)

Function*************************************************************

Synopsis [Starts memory structures.]

Description []

SideEffects []

SeeAlso []

Definition at line 294 of file utilMem.c.

{
    assert( s_vAllocs == NULL && s_vFrees == NULL );
    s_vAllocs = Vec_MemAlloc( 1000 );
    s_vFrees = Vec_MemAlloc( 1000 );
}

static Vec_Mem_t* Vec_MemAlloc ( int  nCap )

inlinestatic

FUNCTION DEFINITIONS ///.

Function*************************************************************

Synopsis [Allocates a vector with the given capacity.]

Description []

SideEffects []

SeeAlso []

Definition at line 70 of file utilMem.c.

{
    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;
}

static void Vec_MemFree ( Vec_Mem_t *  p )

inlinestatic

Function*************************************************************

Synopsis [Frees the vector.]

Description []

SideEffects []

SeeAlso []

Definition at line 93 of file utilMem.c.

{
    ABC_MEM_FREE( p->pArray );
    ABC_MEM_FREE( p );
}

static void Vec_MemGrow ( Vec_Mem_t *  p, int  nCapMin  )

inlinestatic

Function*************************************************************

Synopsis [Resizes the vector to the given capacity.]

Description []

SideEffects []

SeeAlso []

Definition at line 110 of file utilMem.c.

{
    if ( p->nCap >= nCapMin )
        return;
    p->pArray = ABC_MEM_REALLOC( void *, p->pArray, nCapMin ); 
    p->nCap   = nCapMin;
}

static void Vec_MemPush ( Vec_Mem_t *  p, void *  Entry  )

inlinestatic

Function*************************************************************

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 129 of file utilMem.c.

{
    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;
}

static void Vec_MemSort ( Vec_Mem_t *  p, int(*)()  Vec_MemSortCompare  )

static

Function*************************************************************

Synopsis [Sorting the entries by their integer value.]

Description []

SideEffects []

SeeAlso []

Definition at line 152 of file utilMem.c.

{
    if ( p->nSize < 2 )
        return;
    qsort( (void *)p->pArray, p->nSize, sizeof(void *), 
            (int (*)(const void *, const void *)) Vec_MemSortCompare );
}

static Vec_Mem_t* Vec_MemTwoMerge ( Vec_Mem_t *  vArr1, Vec_Mem_t *  vArr2  )

inlinestatic

Function*************************************************************

Synopsis [Finds entries that do not appear in both lists.]

Description [Assumes that the vectors are sorted in the increasing order.]

SideEffects []

SeeAlso []

Definition at line 228 of file utilMem.c.

{
    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;
}

Variable Documentation

int s_fInterrupt = 0

Definition at line 45 of file utilMem.c.

void* s_vAllocs = NULL

INCLUDES ///.

CFile****************************************************************

FileName [utilInt.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Memory recycling utilities.]

Synopsis [Internal declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id:

utilInt.h,v 1.00 2005/06/20 00:00:00 alanmi Exp

]PARAMETERS ///

Definition at line 43 of file utilMem.c.

void* s_vFrees = NULL

Definition at line 44 of file utilMem.c.