vecMem.h File Reference

#include <stdio.h>

Go to the source code of this file.

Data Structures
struct	Vec_Mem_t_

Macros
#define	Vec_MemForEachEntry(p, pEntry, i)   for ( i = 0; (i < Vec_MemEntryNum(p)) && ((pEntry) = Vec_MemReadEntry(p, i)); i++ )
	MACRO DEFINITIONS ///. More...

Typedefs
typedef typedefABC_NAMESPACE_HEADER_START struct Vec_Mem_t_	Vec_Mem_t
	INCLUDES ///. More...

Functions
static Vec_Mem_t *	Vec_MemAlloc (int nEntrySize, int LogPageSze)
	FUNCTION DEFINITIONS ///. More...
static void	Vec_MemFree (Vec_Mem_t *p)
static void	Vec_MemFreeP (Vec_Mem_t **p)
static Vec_Mem_t *	Vec_MemDup (Vec_Mem_t *pVec)
static void	Vec_MemFill (Vec_Mem_t *pVec, int nEntries)
static void	Vec_MemClean (Vec_Mem_t *pVec, int nEntries)
static int	Vec_MemEntrySize (Vec_Mem_t *p)
static int	Vec_MemEntryNum (Vec_Mem_t *p)
static int	Vec_MemPageSize (Vec_Mem_t *p)
static int	Vec_MemPageNum (Vec_Mem_t *p)
static double	Vec_MemMemory (Vec_Mem_t *p)
static word *	Vec_MemReadEntry (Vec_Mem_t *p, int i)
static word *	Vec_MemReadEntryLast (Vec_Mem_t *p)
static void	Vec_MemWriteEntry (Vec_Mem_t *p, int i, word *pEntry)
static word *	Vec_MemGetEntry (Vec_Mem_t *p, int i)
static void	Vec_MemSetEntry (Vec_Mem_t *p, int i, word *pEntry)
static void	Vec_MemPush (Vec_Mem_t *p, word *pEntry)
static void	Vec_MemShrink (Vec_Mem_t *p, int nEntriesNew)
static void	Vec_MemDumpDigit (FILE *pFile, int HexDigit)
static void	Vec_MemDump (FILE *pFile, Vec_Mem_t *pVec)
static void	Vec_MemHashAlloc (Vec_Mem_t *p, int nTableSize)
static void	Vec_MemHashFree (Vec_Mem_t *p)
static unsigned	Vec_MemHashKey (Vec_Mem_t *p, word *pEntry)
static int *	Vec_MemHashLookup (Vec_Mem_t *p, word *pEntry)
static void	Vec_MemHashResize (Vec_Mem_t *p)
static int	Vec_MemHashInsert (Vec_Mem_t *p, word *pEntry)
static Vec_Mem_t *	Vec_MemAllocForTT (int nVars, int fCompl)
static void	Vec_MemAddMuxTT (Vec_Mem_t *p, int nVars)
static void	Vec_MemDumpTruthTables (Vec_Mem_t *p, char *pName, int nLutSize)

Macro Definition Documentation

#define Vec_MemForEachEntry	(		p,
			pEntry,
			i
	)		for ( i = 0; (i < Vec_MemEntryNum(p)) && ((pEntry) = Vec_MemReadEntry(p, i)); i++ )

MACRO DEFINITIONS ///.

Definition at line 68 of file vecMem.h.

Typedef Documentation

typedef typedefABC_NAMESPACE_HEADER_START struct Vec_Mem_t_ Vec_Mem_t

INCLUDES ///.

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

FileName [vecMem.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Resizable arrays.]

Synopsis [Resizable array of memory pieces.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - July 20, 2012.]

Revision [

Id:

vecMem.h,v 1.00 2012/07/20 00:00:00 alanmi Exp

]PARAMETERS ///BASIC TYPES ///

Definition at line 50 of file vecMem.h.

Function Documentation

static void Vec_MemAddMuxTT ( Vec_Mem_t *  p, int  nVars  )

inlinestatic

Definition at line 394 of file vecMem.h.

{
    int Value, nWords = (nVars <= 6 ? 1 : (1 << (nVars - 6)));
    word * uTruth = ABC_ALLOC( word, nWords ); 
    memset( uTruth, 0xCA, sizeof(word) * nWords );
    Value = Vec_MemHashInsert( p, uTruth ); assert( Value == 2 );
    ABC_FREE( uTruth );
}

static Vec_Mem_t* Vec_MemAlloc ( int  nEntrySize, int  LogPageSze  )

inlinestatic

FUNCTION DEFINITIONS ///.

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

Synopsis [Allocates a memory vector.]

Description [Entry size is in terms of 8-byte words. Page size is log2 of the number of entries on one page.]

SideEffects []

SeeAlso []

Definition at line 87 of file vecMem.h.

{
    Vec_Mem_t * p;
    p = ABC_CALLOC( Vec_Mem_t, 1 );
    p->nEntrySize = nEntrySize;
    p->LogPageSze = LogPageSze;
    p->PageMask   = (1 << p->LogPageSze) - 1;
    p->iPage      = -1;
    return p;
}

static Vec_Mem_t* Vec_MemAllocForTT ( int  nVars, int  fCompl  )

inlinestatic

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

Synopsis [Allocates memory vector for storing truth tables.]

Description []

SideEffects []

SeeAlso []

Definition at line 378 of file vecMem.h.

{
    int Value, nWords = (nVars <= 6 ? 1 : (1 << (nVars - 6)));
    word * uTruth = ABC_ALLOC( word, nWords ); 
    Vec_Mem_t * vTtMem = Vec_MemAlloc( nWords, 12 );
    Vec_MemHashAlloc( vTtMem, 10000 );
    memset( uTruth, 0x00, sizeof(word) * nWords );
    Value = Vec_MemHashInsert( vTtMem, uTruth ); assert( Value == 0 );
    if ( fCompl )
        memset( uTruth, 0x55, sizeof(word) * nWords );
    else
        memset( uTruth, 0xAA, sizeof(word) * nWords );
    Value = Vec_MemHashInsert( vTtMem, uTruth ); assert( Value == 1 );
    ABC_FREE( uTruth );
    return vTtMem;
}

static void Vec_MemClean ( Vec_Mem_t *  pVec, int  nEntries  )

inlinestatic

Definition at line 132 of file vecMem.h.

{
}

static void Vec_MemDump ( FILE *  pFile, Vec_Mem_t *  pVec  )

inlinestatic

Definition at line 279 of file vecMem.h.

{
    word * pEntry;
    int i, w, d;
    if ( pFile == stdout )
        printf( "Memory vector has %d entries: \n", Vec_MemEntryNum(pVec) );
    Vec_MemForEachEntry( pVec, pEntry, i )
    {
        for ( w = pVec->nEntrySize - 1; w >= 0; w-- )
            for ( d = 15; d >= 0; d-- )
                Vec_MemDumpDigit( pFile, (int)(pEntry[w] >> (d<<2)) & 15 );
        fprintf( pFile, "\n" );
    }
}

static void Vec_MemDumpDigit ( FILE *  pFile, int  HexDigit  )

inlinestatic

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 271 of file vecMem.h.

{
    assert( HexDigit >= 0 && HexDigit < 16 );
    if ( HexDigit < 10 )
        fprintf( pFile, "%d", HexDigit );
    else
        fprintf( pFile, "%c", 'A' + HexDigit-10 );
}

static void Vec_MemDumpTruthTables ( Vec_Mem_t *  p, char *  pName, int  nLutSize  )

inlinestatic

Definition at line 402 of file vecMem.h.

{
    FILE * pFile;
    char pFileName[1000];
    sprintf( pFileName, "tt_%s_%02d.txt", pName ? pName : NULL, nLutSize );
    pFile = pName ? fopen( pFileName, "wb" ) : stdout;
    Vec_MemDump( pFile, p );
    if ( pFile != stdout )
        fclose( pFile );
    printf( "Dumped %d %d-var truth tables into file \"%s\" (%.2f MB).\n", 
        Vec_MemEntryNum(p), nLutSize, pName ? pFileName : "stdout",
        8.0 * Vec_MemEntryNum(p) * Vec_MemEntrySize(p) / (1 << 20) );
}

static Vec_Mem_t* Vec_MemDup ( Vec_Mem_t *  pVec )

inlinestatic

Definition at line 112 of file vecMem.h.

{
    Vec_Mem_t * p = NULL;
    return p;
}

static int Vec_MemEntryNum ( Vec_Mem_t *  p )

inlinestatic

Definition at line 151 of file vecMem.h.

{
    return p->nEntries;
}

static int Vec_MemEntrySize ( Vec_Mem_t *  p )

inlinestatic

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 147 of file vecMem.h.

{
    return p->nEntrySize;
}

static void Vec_MemFill ( Vec_Mem_t *  pVec, int  nEntries  )

inlinestatic

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

Synopsis [Duplicates the integer array.]

Description []

SideEffects []

SeeAlso []

Definition at line 129 of file vecMem.h.

{
}

static void Vec_MemFree ( Vec_Mem_t *  p )

inlinestatic

Definition at line 97 of file vecMem.h.

{
    int i;
    for ( i = 0; i <= p->iPage; i++ )
        ABC_FREE( p->ppPages[i] );
    ABC_FREE( p->ppPages );
    ABC_FREE( p );
}

static void Vec_MemFreeP ( Vec_Mem_t **  p )

inlinestatic

Definition at line 105 of file vecMem.h.

{
    if ( *p == NULL )
        return;
    Vec_MemFree( *p );
    *p = NULL;
}

static word* Vec_MemGetEntry ( Vec_Mem_t *  p, int  i  )

inlinestatic

Definition at line 206 of file vecMem.h.

{
    assert( i >= 0 );
    if ( i >= p->nEntries )
    {
        int k, iPageNew = (i >> p->LogPageSze);
        if ( p->iPage < iPageNew )
        {
            // realloc page pointers if needed
            if ( iPageNew >= p->nPageAlloc )
                p->ppPages = ABC_REALLOC( word *, p->ppPages, (p->nPageAlloc = p->nPageAlloc ? 2 * p->nPageAlloc : iPageNew + 32) );
            // allocate new pages if needed
            for ( k = p->iPage + 1; k <= iPageNew; k++ )
                p->ppPages[k] = ABC_ALLOC( word, p->nEntrySize * (1 << p->LogPageSze) );
            // update page counter
            p->iPage = iPageNew;
        }
        // update entry counter
        p->nEntries = i + 1;
    }
    return Vec_MemReadEntry( p, i );
}

static void Vec_MemHashAlloc ( Vec_Mem_t *  p, int  nTableSize  )

inlinestatic

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

Synopsis [Hashing entries in the memory vector.]

Description []

SideEffects []

SeeAlso []

Definition at line 305 of file vecMem.h.

{
    assert( p->vTable == NULL && p->vNexts == NULL );
    p->vTable = Vec_IntStartFull( Abc_PrimeCudd(nTableSize) );
    p->vNexts = Vec_IntAlloc( nTableSize );
}

static void Vec_MemHashFree ( Vec_Mem_t *  p )

inlinestatic

Definition at line 311 of file vecMem.h.

{
    if ( p == NULL )
        return;
    Vec_IntFreeP( &p->vTable );
    Vec_IntFreeP( &p->vNexts );
}

static int Vec_MemHashInsert ( Vec_Mem_t *  p, word *  pEntry  )

static

Definition at line 351 of file vecMem.h.

{
    int * pSpot;
    if ( p->nEntries > Vec_IntSize(p->vTable) )
        Vec_MemHashResize( p );
    pSpot = Vec_MemHashLookup( p, pEntry );
    if ( *pSpot != -1 )
        return *pSpot;
    *pSpot = Vec_IntSize(p->vNexts);
    Vec_IntPush( p->vNexts, -1 );
    Vec_MemPush( p, pEntry );
    assert( p->nEntries == Vec_IntSize(p->vNexts) );
    return Vec_IntSize(p->vNexts) - 1;
}

static unsigned Vec_MemHashKey ( Vec_Mem_t *  p, word *  pEntry  )

inlinestatic

Definition at line 318 of file vecMem.h.

{
    static int s_Primes[8] = { 1699, 4177, 5147, 5647, 6343, 7103, 7873, 8147 };
    int i, nData = 2 * p->nEntrySize;
    unsigned * pData = (unsigned *)pEntry;
    unsigned uHash = 0;
    for ( i = 0; i < nData; i++ )
        uHash += pData[i] * s_Primes[i & 0x7];
    return uHash % Vec_IntSize(p->vTable);
}

static int* Vec_MemHashLookup ( Vec_Mem_t *  p, word *  pEntry  )

static

Definition at line 328 of file vecMem.h.

{
    int * pSpot = Vec_IntEntryP( p->vTable, Vec_MemHashKey(p, pEntry) );
    for ( ; *pSpot != -1; pSpot = Vec_IntEntryP(p->vNexts, *pSpot) )
        if ( !memcmp( Vec_MemReadEntry(p, *pSpot), pEntry, sizeof(word) * p->nEntrySize ) ) // equal
            return pSpot;
    return pSpot;
}

static void Vec_MemHashResize ( Vec_Mem_t *  p )

static

Definition at line 336 of file vecMem.h.

{
    word * pEntry;
    int i, * pSpot;
    Vec_IntFill( p->vTable, Abc_PrimeCudd(2 * Vec_IntSize(p->vTable)), -1 );
    Vec_IntClear( p->vNexts );
    Vec_MemForEachEntry( p, pEntry, i )
    {
        pSpot = Vec_MemHashLookup( p, pEntry );
        assert( *pSpot == -1 );
        *pSpot = Vec_IntSize(p->vNexts);
        Vec_IntPush( p->vNexts, -1 );
    }
    assert( p->nEntries == Vec_IntSize(p->vNexts) );
}

static double Vec_MemMemory ( Vec_Mem_t *  p )

inlinestatic

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 175 of file vecMem.h.

{
    return (double)sizeof(word) * p->nEntrySize * (1 << p->LogPageSze) * (p->iPage + 1) + (double)sizeof(word *) * p->nPageAlloc + (double)sizeof(Vec_Mem_t);
}

static int Vec_MemPageNum ( Vec_Mem_t *  p )

inlinestatic

Definition at line 159 of file vecMem.h.

{
    return p->iPage+1;
}

static int Vec_MemPageSize ( Vec_Mem_t *  p )

inlinestatic

Definition at line 155 of file vecMem.h.

{
    return p->LogPageSze;
}

static void Vec_MemPush ( Vec_Mem_t *  p, word *  pEntry  )

inlinestatic

Definition at line 233 of file vecMem.h.

{
    word * pPlace = Vec_MemGetEntry( p, p->nEntries );
    memmove( pPlace, pEntry, sizeof(word) * p->nEntrySize );
}

static word* Vec_MemReadEntry ( Vec_Mem_t *  p, int  i  )

inlinestatic

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 191 of file vecMem.h.

{
    assert( i >= 0 && i < p->nEntries );
    return p->ppPages[i >> p->LogPageSze] + p->nEntrySize * (i & p->PageMask);
}

static word* Vec_MemReadEntryLast ( Vec_Mem_t *  p )

inlinestatic

Definition at line 196 of file vecMem.h.

{
    assert( p->nEntries > 0 );
    return Vec_MemReadEntry( p, p->nEntries-1 );
}

static void Vec_MemSetEntry ( Vec_Mem_t *  p, int  i, word *  pEntry  )

inlinestatic

Definition at line 228 of file vecMem.h.

{
    word * pPlace = Vec_MemGetEntry( p, i );
    memmove( pPlace, pEntry, sizeof(word) * p->nEntrySize );
}

static void Vec_MemShrink ( Vec_Mem_t *  p, int  nEntriesNew  )

inlinestatic

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

Synopsis []

Description []

SideEffects []

SeeAlso []

Definition at line 250 of file vecMem.h.

{
    int i, iPageOld = p->iPage;
    assert( nEntriesNew <= p->nEntries );
    p->nEntries = nEntriesNew;
    p->iPage = (nEntriesNew >> p->LogPageSze);
    for ( i = p->iPage + 1; i <= iPageOld; i++ )
        ABC_FREE( p->ppPages[i] );
}

static void Vec_MemWriteEntry ( Vec_Mem_t *  p, int  i, word *  pEntry  )

inlinestatic

Definition at line 201 of file vecMem.h.

{
    word * pPlace = Vec_MemReadEntry( p, i );
    memmove( pPlace, pEntry, sizeof(word) * p->nEntrySize );
}