exorCubes.c File Reference

#include "exor.h"

Include dependency graph for exorCubes.c:

Go to the source code of this file.

Functions
int	AllocateCover (int nCubes, int nWordsIn, int nWordsOut)
	FUNCTIONS OF THIS MODULE ///.
void	DelocateCover ()
void	AddToFreeCubes (Cube *p)
	FREE CUBE LIST MANIPULATION FUNCTIONS ///.
Cube *	GetFreeCube ()

Variables
ABC_NAMESPACE_IMPL_START cinfo	g_CoverInfo
	EXTERNAL FUNCTIONS ///.
Cube **	s_pCoverMemory
	EXPORTED VARIABLES ///.
Cube *	s_CubesFree

Function Documentation

AddToFreeCubes()

void AddToFreeCubes

(

Cube *

pC

)

FREE CUBE LIST MANIPULATION FUNCTIONS ///.

Definition at line 157 of file exorCubes.c.

{
    assert( p );
    assert( p->Prev == NULL ); // the cube should not be in use
    assert( p->Next == NULL );
    assert( p->ID );
 
    p->Next = s_CubesFree;
    s_CubesFree = p;
 
    // set the ID of the cube to 0, 
    // so that cube pair garbage collection could recognize it as different
    p->ID = 0;
 
    g_CoverInfo.nCubesFree++;
}

Here is the caller graph for this function:

AllocateCover()

int AllocateCover	(	int	nCubes,
		int	nWordsIn,
		int	nWordsOut )

FUNCTIONS OF THIS MODULE ///.

CUBE COVER MEMORY MANAGEMENT //.

Definition at line 90 of file exorCubes.c.

{
    int OneCubeSize;
    int OneInputSetSize;
    Cube ** pp;
    int TotalSize;
    int i, k;
 
    // determine the size of one cube WITH storage for bits
    OneCubeSize = sizeof(Cube) + (nWordsIn+nWordsOut)*sizeof(unsigned);
    // determine what is the amount of storage for the input part of the cube 
    OneInputSetSize = nWordsIn*sizeof(unsigned);
 
    // allocate memory for the array of pointers
    pp = (Cube **)ABC_ALLOC( Cube *, nCubes );
    if ( pp == NULL )
        return 0;
 
    // determine the size of the total cube cover
    TotalSize = nCubes*OneCubeSize;
    // allocate and clear memory for the cover in one large piece
    pp[0] = (Cube *)ABC_ALLOC( char, TotalSize );
    if ( pp[0] == NULL )
        return 0;
    memset( pp[0], 0, (size_t)TotalSize );
 
    // assign pointers to cubes and bit strings inside this piece
    pp[0]->pCubeDataIn  = (unsigned*)(pp[0] + 1);
    pp[0]->pCubeDataOut = (unsigned*)((char*)pp[0]->pCubeDataIn + OneInputSetSize);
    for ( i = 1; i < nCubes; i++ )
    {
        pp[i] = (Cube *)((char*)pp[i-1] + OneCubeSize);
        pp[i]->pCubeDataIn = (unsigned*)(pp[i] + 1);
        pp[i]->pCubeDataOut = (unsigned*)((char*)pp[i]->pCubeDataIn + OneInputSetSize);
    }
 
    // connect the cubes into the list using Next pointers
    for ( k = 0; k < nCubes-1; k++ )
        pp[k]->Next = pp[k+1];
    // the last pointer is already set to NULL
 
    // assign the head of the free list
    s_CubesFree = pp[0];
    // set the counters of the used and free cubes
    g_CoverInfo.nCubesInUse = 0;
    g_CoverInfo.nCubesFree = nCubes;
 
    // save the pointer to the allocated memory
    s_pCoverMemory = pp;
 
    assert ( g_CoverInfo.nCubesInUse + g_CoverInfo.nCubesFree == g_CoverInfo.nCubesAlloc );
 
    return nCubes*sizeof(Cube *) + TotalSize;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DelocateCover()

void DelocateCover

(

)

Definition at line 147 of file exorCubes.c.

{
    ABC_FREE( s_pCoverMemory[0] );
    ABC_FREE( s_pCoverMemory );
}

Here is the caller graph for this function:

GetFreeCube()

Cube * GetFreeCube

(

)

Definition at line 174 of file exorCubes.c.

{
    Cube * p;
    assert( s_CubesFree );
    p = s_CubesFree;
    s_CubesFree = s_CubesFree->Next;
    p->Next = NULL;
    g_CoverInfo.nCubesFree--;
    return p;
}

Here is the caller graph for this function:

Variable Documentation

g_CoverInfo

ABC_NAMESPACE_IMPL_START cinfo g_CoverInfo

extern

EXTERNAL FUNCTIONS ///.

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

FileName [exorCubes.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Exclusive sum-of-product minimization.]

Synopsis [Cube manipulation.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id

exorCubes.c,v 1.0 2005/06/20 00:00:00 alanmi Exp

]

                                                            ///
            Implementation of EXORCISM - 4                  ///
        An Exclusive Sum-of-Product Minimizer               ///
                                                            ///
         Alan Mishchenko  <alanmi@ee.pdx.edu>               ///
                                                            ///

                                                            ///
        Cube Allocation and Free Cube Management            ///
                                                            ///

Ver. 1.0. Started - July 18, 2000. Last update - July 20, 2000 /// Ver. 1.1. Started - July 24, 2000. Last update - July 29, 2000 /// Ver. 1.2. Started - July 30, 2000. Last update - July 30, 2000 /// Ver. 1.5. Started - Aug 19, 2000. Last update - Aug 19, 2000 /// ///

This software was tested with the BDD package "CUDD", v.2.3.0 /// by Fabio Somenzi /// http://vlsi.colorado.edu/~fabio/ /// EXTERNAL VARIABLES ///

EXTERNAL FUNCTIONS ///.

MACRO DEFINITIONS ///.

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

FileName [exor.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [Exclusive sum-of-product minimization.]

Synopsis [Main procedure.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id

exor.c,v 1.0 2005/06/20 00:00:00 alanmi Exp

]

                                                            ///
            Implementation of EXORCISM - 4                  ///
        An Exclusive Sum-of-Product Minimizer               ///
         Alan Mishchenko  <alanmi@ee.pdx.edu>               ///
                                                            ///

                                                            ///
                   Main Module                              ///
          ESOP Minimization Task Coordinator                ///
                                                            ///
    1) interprets command line                              ///  
    2) calls the approapriate reading procedure             ///
    3) calls the minimization module                        ///
                                                            ///

Ver. 1.0. Started - July 18, 2000. Last update - July 20, 2000 /// Ver. 1.1. Started - July 24, 2000. Last update - July 29, 2000 /// Ver. 1.4. Started - Aug 10, 2000. Last update - Aug 26, 2000 /// Ver. 1.6. Started - Sep 11, 2000. Last update - Sep 15, 2000 /// Ver. 1.7. Started - Sep 20, 2000. Last update - Sep 23, 2000 /// ///

This software was tested with the BDD package "CUDD", v.2.3.0 /// by Fabio Somenzi /// http://vlsi.colorado.edu/~fabio/ ///

Definition at line 58 of file exor.c.

s_CubesFree

Cube* s_CubesFree

Definition at line 84 of file exorCubes.c.

s_pCoverMemory

Cube** s_pCoverMemory

EXPORTED VARIABLES ///.

STATIC VARIABLES ///

Definition at line 81 of file exorCubes.c.