fraigMem.c File Reference

#include "fraigInt.h"

Include dependency graph for fraigMem.c:

Go to the source code of this file.

Classes
struct	Fraig_MemFixed_t_
	DECLARATIONS ///. More...

Functions
Fraig_MemFixed_t *	Fraig_MemFixedStart (int nEntrySize)
	FUNCTION DEFINITIONS ///.
void	Fraig_MemFixedStop (Fraig_MemFixed_t *p, int fVerbose)
char *	Fraig_MemFixedEntryFetch (Fraig_MemFixed_t *p)
void	Fraig_MemFixedEntryRecycle (Fraig_MemFixed_t *p, char *pEntry)
void	Fraig_MemFixedRestart (Fraig_MemFixed_t *p)
int	Fraig_MemFixedReadMemUsage (Fraig_MemFixed_t *p)

Function Documentation

Fraig_MemFixedEntryFetch()

char * Fraig_MemFixedEntryFetch

(

Fraig_MemFixed_t *

p

)

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

Synopsis [Extracts one entry from the memory manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 131 of file fraigMem.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:

Fraig_MemFixedEntryRecycle()

void Fraig_MemFixedEntryRecycle	(	Fraig_MemFixed_t *	p,
		char *	pEntry )

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

Synopsis [Returns one entry into the memory manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 182 of file fraigMem.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;
}

Fraig_MemFixedReadMemUsage()

int Fraig_MemFixedReadMemUsage

(

Fraig_MemFixed_t *

p

)

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

Synopsis [Reports the memory usage.]

Description []

SideEffects []

SeeAlso []

Definition at line 240 of file fraigMem.c.

{
    return p->nMemoryAlloc;
}

Fraig_MemFixedRestart()

void Fraig_MemFixedRestart

(

Fraig_MemFixed_t *

p

)

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

Synopsis [Frees all associated memory and resets the manager.]

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

SideEffects []

SeeAlso []

Definition at line 202 of file fraigMem.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;
}

Fraig_MemFixedStart()

Fraig_MemFixed_t * Fraig_MemFixedStart

(

int

nEntrySize

)

FUNCTION DEFINITIONS ///.

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

Synopsis [Starts the internal memory manager.]

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

SideEffects []

SeeAlso []

Definition at line 63 of file fraigMem.c.

{
    Fraig_MemFixed_t * p;
 
    p = ABC_ALLOC( Fraig_MemFixed_t, 1 );
    memset( p, 0, sizeof(Fraig_MemFixed_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:

Fraig_MemFixedStop()

void Fraig_MemFixedStop	(	Fraig_MemFixed_t *	p,
		int	fVerbose )

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

Synopsis [Stops the internal memory manager.]

Description []

SideEffects []

SeeAlso []

Definition at line 102 of file fraigMem.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: