#include "misc/util/abc_global.h"

Include dependency graph for mem.h:

This graph shows which files directly or indirectly include this file:

Typedefs
typedef typedefABC_NAMESPACE_HEADER_START struct Mem_Fixed_t_	Mem_Fixed_t
	DECLARATIONS ///.

typedef struct Mem_Flex_t_	Mem_Flex_t

typedef struct Mem_Step_t_	Mem_Step_t

Functions
Mem_Fixed_t *	Mem_FixedStart (int nEntrySize)
	FUNCTION DEFINITIONS ///.

void	Mem_FixedStop (Mem_Fixed_t *p, int fVerbose)

char *	Mem_FixedEntryFetch (Mem_Fixed_t *p)

void	Mem_FixedEntryRecycle (Mem_Fixed_t p, char pEntry)

void	Mem_FixedRestart (Mem_Fixed_t *p)

int	Mem_FixedReadMemUsage (Mem_Fixed_t *p)

int	Mem_FixedReadMaxEntriesUsed (Mem_Fixed_t *p)

Mem_Flex_t *	Mem_FlexStart ()

void	Mem_FlexStop (Mem_Flex_t *p, int fVerbose)

void	Mem_FlexStop2 (Mem_Flex_t *p)

char *	Mem_FlexEntryFetch (Mem_Flex_t *p, int nBytes)

void	Mem_FlexRestart (Mem_Flex_t *p)

int	Mem_FlexReadMemUsage (Mem_Flex_t *p)

Mem_Step_t *	Mem_StepStart (int nSteps)

void	Mem_StepStop (Mem_Step_t *p, int fVerbose)

char *	Mem_StepEntryFetch (Mem_Step_t *p, int nBytes)

void	Mem_StepEntryRecycle (Mem_Step_t p, char pEntry, int nBytes)

int	Mem_StepReadMemUsage (Mem_Step_t *p)

Typedef Documentation

◆ Mem_Fixed_t

typedef typedefABC_NAMESPACE_HEADER_START struct Mem_Fixed_t_ Mem_Fixed_t

DECLARATIONS ///.

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

FileName [mem.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Memory management.]

Synopsis [External declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

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

]

Definition at line 33 of file mem.h.

◆ Mem_Flex_t

typedef struct Mem_Flex_t_ Mem_Flex_t

Definition at line 34 of file mem.h.

◆ Mem_Step_t

typedef struct Mem_Step_t_ Mem_Step_t

Definition at line 35 of file mem.h.

Function Documentation

◆ Mem_FixedEntryFetch()

char * Mem_FixedEntryFetch ( Mem_Fixed_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 184 of file mem.c.

{
    char * pTemp;
    int i;
 
    // check if there are still free entries
    if ( p->nEntriesUsed == p->nEntriesAlloc )
    { // need to allocate more entries
        assert( p->pEntriesFree == NULL );
        if ( p->nChunks == p->nChunksAlloc )
        {
            p->nChunksAlloc *= 2;
            p->pChunks = ABC_REALLOC( char *, p->pChunks, p->nChunksAlloc ); 
        }
        p->pEntriesFree = ABC_ALLOC( char, p->nEntrySize * p->nChunkSize );
        p->nMemoryAlloc += p->nEntrySize * p->nChunkSize;
        // transform these entries into a linked list
        pTemp = p->pEntriesFree;
        for ( i = 1; i < p->nChunkSize; i++ )
        {
            *((char **)pTemp) = pTemp + p->nEntrySize;
            pTemp += p->nEntrySize;
        }
        // set the last link
        *((char **)pTemp) = NULL;
        // add the chunk to the chunk storage
        p->pChunks[ p->nChunks++ ] = p->pEntriesFree;
        // add to the number of entries allocated
        p->nEntriesAlloc += p->nChunkSize;
    }
    // incrememt the counter of used entries
    p->nEntriesUsed++;
    if ( p->nEntriesMax < p->nEntriesUsed )
        p->nEntriesMax = p->nEntriesUsed;
    // return the first entry in the free entry list
    pTemp = p->pEntriesFree;
    p->pEntriesFree = *((char **)pTemp);
    return pTemp;
}

Here is the caller graph for this function:

◆ Mem_FixedEntryRecycle()

void Mem_FixedEntryRecycle	(	Mem_Fixed_t *	p,
		char *	pEntry )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 235 of file mem.c.

{
    // decrement the counter of used entries
    p->nEntriesUsed--;
    // add the entry to the linked list of free entries
    *((char **)pEntry) = p->pEntriesFree;
    p->pEntriesFree = pEntry;
}

Here is the caller graph for this function:

◆ Mem_FixedReadMaxEntriesUsed()

int Mem_FixedReadMaxEntriesUsed ( Mem_Fixed_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 309 of file mem.c.

{
    return p->nEntriesMax;
}

◆ Mem_FixedReadMemUsage()

int Mem_FixedReadMemUsage ( Mem_Fixed_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 293 of file mem.c.

{
    return p->nMemoryAlloc;
}

Here is the caller graph for this function:

◆ Mem_FixedRestart()

void Mem_FixedRestart ( Mem_Fixed_t * p )

extern

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

Synopsis []

Description [Relocates all the memory except the first chunk.]

SideEffects []

SeeAlso []

Definition at line 255 of file mem.c.

{
    int i;
    char * pTemp;
 
    // deallocate all chunks except the first one
    for ( i = 1; i < p->nChunks; i++ )
        ABC_FREE( p->pChunks[i] );
    p->nChunks = 1;
    // transform these entries into a linked list
    pTemp = p->pChunks[0];
    for ( i = 1; i < p->nChunkSize; i++ )
    {
        *((char **)pTemp) = pTemp + p->nEntrySize;
        pTemp += p->nEntrySize;
    }
    // set the last link
    *((char **)pTemp) = NULL;
    // set the free entry list
    p->pEntriesFree  = p->pChunks[0];
    // set the correct statistics
    p->nMemoryAlloc  = p->nEntrySize * p->nChunkSize;
    p->nMemoryUsed   = 0;
    p->nEntriesAlloc = p->nChunkSize;
    p->nEntriesUsed  = 0;
}

Here is the caller graph for this function:

◆ Mem_FixedStart()

Mem_Fixed_t * Mem_FixedStart ( int nEntrySize )

extern

FUNCTION DEFINITIONS ///.

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

Synopsis [Allocates memory pieces of fixed size.]

Description [The size of the chunk is computed as the minimum of 1024 entries and 64K. Can only work with entry size at least 4 byte long.]

SideEffects []

SeeAlso []

Definition at line 100 of file mem.c.

{
    Mem_Fixed_t * p;
 
    p = ABC_ALLOC( Mem_Fixed_t, 1 );
    memset( p, 0, sizeof(Mem_Fixed_t) );
 
    p->nEntrySize    = nEntrySize;
    p->nEntriesAlloc = 0;
    p->nEntriesUsed  = 0;
    p->pEntriesFree  = NULL;
 
    if ( nEntrySize * (1 << 10) < (1<<16) )
        p->nChunkSize = (1 << 10);
    else
        p->nChunkSize = (1<<16) / nEntrySize;
    if ( p->nChunkSize < 8 )
        p->nChunkSize = 8;
 
    p->nChunksAlloc  = 64;
    p->nChunks       = 0;
    p->pChunks       = ABC_ALLOC( char *, p->nChunksAlloc );
 
    p->nMemoryUsed   = 0;
    p->nMemoryAlloc  = 0;
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Mem_FixedStop()

void Mem_FixedStop	(	Mem_Fixed_t *	p,
		int	fVerbose )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 139 of file mem.c.

{
    int i;
    if ( p == NULL )
        return;
    if ( fVerbose )
    {
        printf( "Fixed memory manager: Entry = %5d. Chunk = %5d. Chunks used = %5d.\n",
            p->nEntrySize, p->nChunkSize, p->nChunks );
        printf( "   Entries used = %8d. Entries peak = %8d. Memory used = %8d. Memory alloc = %8d.\n",
            p->nEntriesUsed, p->nEntriesMax, p->nEntrySize * p->nEntriesUsed, p->nMemoryAlloc );
    }
    for ( i = 0; i < p->nChunks; i++ )
        ABC_FREE( p->pChunks[i] );
    ABC_FREE( p->pChunks );
    ABC_FREE( p );
}

Here is the caller graph for this function:

◆ Mem_FlexEntryFetch()

char * Mem_FlexEntryFetch	(	Mem_Flex_t *	p,
		int	nBytes )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 388 of file mem.c.

{
    char * pTemp;
    // check if there are still free entries
    if ( p->pCurrent == NULL || p->pCurrent + nBytes > p->pEnd )
    { // need to allocate more entries
        if ( p->nChunks == p->nChunksAlloc )
        {
            p->nChunksAlloc *= 2;
            p->pChunks = ABC_REALLOC( char *, p->pChunks, p->nChunksAlloc ); 
        }
        if ( nBytes > p->nChunkSize )
        {
            // resize the chunk size if more memory is requested than it can give
            // (ideally, this should never happen)
            p->nChunkSize = 2 * nBytes;
        }
        p->pCurrent = ABC_ALLOC( char, p->nChunkSize );
        p->pEnd     = p->pCurrent + p->nChunkSize;
        p->nMemoryAlloc += p->nChunkSize;
        // add the chunk to the chunk storage
        p->pChunks[ p->nChunks++ ] = p->pCurrent;
    }
    assert( p->pCurrent + nBytes <= p->pEnd );
    // increment the counter of used entries
    p->nEntriesUsed++;
    // keep track of the memory used
    p->nMemoryUsed += nBytes;
    // return the next entry
    pTemp = p->pCurrent;
    p->pCurrent += nBytes;
    return pTemp;
}

Here is the caller graph for this function:

◆ Mem_FlexReadMemUsage()

int Mem_FlexReadMemUsage ( Mem_Flex_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 461 of file mem.c.

{
    return p->nMemoryUsed;
}

Here is the caller graph for this function:

◆ Mem_FlexRestart()

void Mem_FlexRestart ( Mem_Flex_t * p )

extern

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

Synopsis []

Description [Relocates all the memory except the first chunk.]

SideEffects []

SeeAlso []

Definition at line 433 of file mem.c.

{
    int i;
    if ( p->nChunks == 0 )
        return;
    // deallocate all chunks except the first one
    for ( i = 1; i < p->nChunks; i++ )
        ABC_FREE( p->pChunks[i] );
    p->nChunks  = 1;
    p->nMemoryAlloc = p->nChunkSize;
    // transform these entries into a linked list
    p->pCurrent = p->pChunks[0];
    p->pEnd     = p->pCurrent + p->nChunkSize;
    p->nEntriesUsed = 0;
    p->nMemoryUsed = 0;
}

◆ Mem_FlexStart()

Mem_Flex_t * Mem_FlexStart ( )

extern

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

Synopsis [Allocates entries of flexible size.]

Description [Can only work with entry size at least 4 byte long.]

SideEffects []

SeeAlso []

Definition at line 327 of file mem.c.

{
    Mem_Flex_t * p;
 
    p = ABC_ALLOC( Mem_Flex_t, 1 );
    memset( p, 0, sizeof(Mem_Flex_t) );
 
    p->nEntriesUsed  = 0;
    p->pCurrent      = NULL;
    p->pEnd          = NULL;
 
    p->nChunkSize    = (1 << 12);
    p->nChunksAlloc  = 64;
    p->nChunks       = 0;
    p->pChunks       = ABC_ALLOC( char *, p->nChunksAlloc );
 
    p->nMemoryUsed   = 0;
    p->nMemoryAlloc  = 0;
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Mem_FlexStop()

void Mem_FlexStop	(	Mem_Flex_t *	p,
		int	fVerbose )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 359 of file mem.c.

{
    int i;
    if ( p == NULL )
        return;
    if ( fVerbose )
    {
        printf( "Flexible memory manager: Chunk size = %d. Chunks used = %d.\n",
            p->nChunkSize, p->nChunks );
        printf( "   Entries used = %d. Memory used = %d. Memory alloc = %d.\n",
            p->nEntriesUsed, p->nMemoryUsed, p->nMemoryAlloc );
    }
    for ( i = 0; i < p->nChunks; i++ )
        ABC_FREE( p->pChunks[i] );
    ABC_FREE( p->pChunks );
    ABC_FREE( p );
}

Here is the caller graph for this function:

◆ Mem_FlexStop2()

void Mem_FlexStop2 ( Mem_Flex_t * p )

extern

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

Synopsis [Wrapper for Mem_FlexStop for use in Vec_AttAlloc]

Description []

SideEffects []

SeeAlso []

Definition at line 168 of file mem.c.

{
     Mem_FlexStop( p, 0 );  
}

Here is the call graph for this function:

◆ Mem_StepEntryFetch()

char * Mem_StepEntryFetch	(	Mem_Step_t *	p,
		int	nBytes )

extern

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

Synopsis [Creates the entry.]

Description []

SideEffects []

SeeAlso []

Definition at line 553 of file mem.c.

{
    if ( nBytes == 0 )
        return NULL;
    if ( nBytes > p->nMapSize )
    {
//        printf( "Allocating %d bytes.\n", nBytes );
//        return ABC_ALLOC( char, nBytes );
        if ( p->nLargeChunks == p->nLargeChunksAlloc )
        {
            if ( p->nLargeChunksAlloc == 0 )
                p->nLargeChunksAlloc = 32;
            p->nLargeChunksAlloc *= 2;
            p->pLargeChunks = (void **)ABC_REALLOC( char *, p->pLargeChunks, p->nLargeChunksAlloc ); 
        }
        p->pLargeChunks[ p->nLargeChunks++ ] = ABC_ALLOC( char, nBytes );
        return (char *)p->pLargeChunks[ p->nLargeChunks - 1 ];
    }
    return Mem_FixedEntryFetch( p->pMap[nBytes] );
}

Here is the call graph for this function:

◆ Mem_StepEntryRecycle()

void Mem_StepEntryRecycle	(	Mem_Step_t *	p,
		char *	pEntry,
		int	nBytes )

extern

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

Synopsis [Recycles the entry.]

Description []

SideEffects []

SeeAlso []

Definition at line 586 of file mem.c.

{
    if ( nBytes == 0 )
        return;
    if ( nBytes > p->nMapSize )
    {
//        ABC_FREE( pEntry );
        return;
    }
    Mem_FixedEntryRecycle( p->pMap[nBytes], pEntry );
}

Here is the call graph for this function:

◆ Mem_StepReadMemUsage()

int Mem_StepReadMemUsage ( Mem_Step_t * p )

extern

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 609 of file mem.c.

{
    int i, nMemTotal = 0;
    for ( i = 0; i < p->nMems; i++ )
        nMemTotal += p->pMems[i]->nMemoryAlloc;
    return nMemTotal;
}

Here is the caller graph for this function:

◆ Mem_StepStart()

Mem_Step_t * Mem_StepStart ( int nSteps )

extern

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

Synopsis [Starts the hierarchical memory manager.]

Description [This manager can allocate entries of any size. Iternally they are mapped into the entries with the number of bytes equal to the power of 2. The smallest entry size is 8 bytes. The next one is 16 bytes etc. So, if the user requests 6 bytes, he gets 8 byte entry. If we asks for 25 bytes, he gets 32 byte entry etc. The input parameters "nSteps" says how many fixed memory managers are employed internally. Calling this procedure with nSteps equal to 10 results in 10 hierarchically arranged internal memory managers, which can allocate up to 4096 (1Kb) entries. Requests for larger entries are handed over to malloc() and then ABC_FREE()ed.]

SideEffects []

SeeAlso []

Definition at line 490 of file mem.c.

{
    Mem_Step_t * p;
    int i, k;
    p = ABC_ALLOC( Mem_Step_t, 1 );
    memset( p, 0, sizeof(Mem_Step_t) );
    p->nMems = nSteps;
    // start the fixed memory managers
    p->pMems = ABC_ALLOC( Mem_Fixed_t *, p->nMems );
    for ( i = 0; i < p->nMems; i++ )
        p->pMems[i] = Mem_FixedStart( (8<<i) );
    // set up the mapping of the required memory size into the corresponding manager
    p->nMapSize = (4<<p->nMems);
    p->pMap = ABC_ALLOC( Mem_Fixed_t *, p->nMapSize+1 );
    p->pMap[0] = NULL;
    for ( k = 1; k <= 4; k++ )
        p->pMap[k] = p->pMems[0];
    for ( i = 0; i < p->nMems; i++ )
        for ( k = (4<<i)+1; k <= (8<<i); k++ )
            p->pMap[k] = p->pMems[i];
//for ( i = 1; i < 100; i ++ )
//printf( "%10d: size = %10d\n", i, p->pMap[i]->nEntrySize );
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Mem_StepStop()

void Mem_StepStop	(	Mem_Step_t *	p,
		int	fVerbose )

extern

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

Synopsis [Stops the memory manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 526 of file mem.c.

{
    int i;
    for ( i = 0; i < p->nMems; i++ )
        Mem_FixedStop( p->pMems[i], fVerbose );
    if ( p->pLargeChunks ) 
    {
        for ( i = 0; i < p->nLargeChunks; i++ )
            ABC_FREE( p->pLargeChunks[i] );
        ABC_FREE( p->pLargeChunks );
    }
    ABC_FREE( p->pMems );
    ABC_FREE( p->pMap );
    ABC_FREE( p );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Typedefs

Functions

Typedef Documentation

◆ Mem_Fixed_t

◆ Mem_Flex_t

◆ Mem_Step_t

Function Documentation

◆ Mem_FixedEntryFetch()

◆ Mem_FixedEntryRecycle()

◆ Mem_FixedReadMaxEntriesUsed()

◆ Mem_FixedReadMemUsage()

◆ Mem_FixedRestart()

◆ Mem_FixedStart()

◆ Mem_FixedStop()

◆ Mem_FlexEntryFetch()

◆ Mem_FlexReadMemUsage()

◆ Mem_FlexRestart()

◆ Mem_FlexStart()

◆ Mem_FlexStop()

◆ Mem_FlexStop2()

◆ Mem_StepEntryFetch()

◆ Mem_StepEntryRecycle()

◆ Mem_StepReadMemUsage()

◆ Mem_StepStart()

◆ Mem_StepStop()