spAllocate.c File Reference

#include "spConfig.h"
#include "spmatrix.h"
#include "spDefs.h"
#include "spmalloc.h"

Include dependency graph for spAllocate.c:

Go to the source code of this file.

Defines
#define	spINSIDE_SPARSE
Functions
static	InitializeElementBlocks ()
static	RecordAllocation ()
static	AllocateBlockOfAllocationList ()
char *	spCreate (int Size, SPBOOLEAN Complex, int *pError)
ElementPtr	spcGetElement (MatrixPtr Matrix)
static	InitializeElementBlocks (MatrixPtr Matrix, int InitialNumberOfElements, int NumberOfFillinsExpected)
ElementPtr	spcGetFillin (MatrixPtr Matrix)
static	RecordAllocation (MatrixPtr Matrix, char *AllocatedPtr)
static	AllocateBlockOfAllocationList (MatrixPtr Matrix)
void	spDestroy (char *eMatrix)
int	spError (char *eMatrix)
void	spWhereSingular (char *eMatrix, int *pRow, int *pCol)
int	spGetSize (char *eMatrix, SPBOOLEAN External)
void	spSetReal (char *eMatrix)
void	spSetComplex (char *eMatrix)
int	spFillinCount (char *eMatrix)
int	spElementCount (char *eMatrix)

---

Define Documentation

#define spINSIDE_SPARSE

Definition at line 63 of file spAllocate.c.

---

Function Documentation

static AllocateBlockOfAllocationList

(

MatrixPtr

Matrix

)

[static]

Definition at line 568 of file spAllocate.c.

References AllocationRecord::AllocatedPtr, I, AllocationRecord::NextRecord, NULL, SPALLOC, and spNO_MEMORY.

{
register  int  I;
register  AllocationListPtr  ListPtr;

/* Begin `AllocateBlockOfAllocationList'. */
/* Allocate block of records for allocation list. */
    ListPtr = SPALLOC(struct AllocationRecord, (ELEMENTS_PER_ALLOCATION+1));
    if (ListPtr == NULL)
    {   Matrix->Error = spNO_MEMORY;
        return 0;
    }

/* String entries of allocation list into singly linked list.  List is linked
   such that any record points to the one before it. */

    ListPtr->NextRecord = Matrix->TopOfAllocationList;
    Matrix->TopOfAllocationList = ListPtr;
    ListPtr += ELEMENTS_PER_ALLOCATION;
    for (I = ELEMENTS_PER_ALLOCATION; I > 0; I--)
    {    ListPtr->NextRecord = ListPtr - 1;
         ListPtr--;
    }

/* Record allocation of space for allocation list on allocation list. */
    Matrix->TopOfAllocationList->AllocatedPtr = (char *)ListPtr;
    Matrix->RecordsRemaining = ELEMENTS_PER_ALLOCATION;

    return 0;
}

static AllocateBlockOfAllocationList

(

)

[static]

Referenced by RecordAllocation().

Here is the caller graph for this function:

static InitializeElementBlocks	(	MatrixPtr	Matrix,
		int	InitialNumberOfElements,
		int	NumberOfFillinsExpected
	)			[static]

Definition at line 368 of file spAllocate.c.

References NULL, RecordAllocation(), SPALLOC, and spNO_MEMORY.

{
ElementPtr  pElement;

/* Begin `InitializeElementBlocks'. */

/* Allocate block of MatrixElements for elements. */
    pElement = SPALLOC(struct MatrixElement, InitialNumberOfElements);
    RecordAllocation( Matrix, (char *)pElement );
    if (Matrix->Error == spNO_MEMORY) return 0;
    Matrix->ElementsRemaining = InitialNumberOfElements;
    Matrix->NextAvailElement = pElement;

/* Allocate block of MatrixElements for fill-ins. */
    pElement = SPALLOC(struct MatrixElement, NumberOfFillinsExpected);
    RecordAllocation( Matrix, (char *)pElement );
    if (Matrix->Error == spNO_MEMORY) return 0;
    Matrix->FillinsRemaining = NumberOfFillinsExpected;
    Matrix->NextAvailFillin = pElement;

/* Allocate a fill-in list structure. */
    Matrix->FirstFillinListNode = SPALLOC(struct FillinListNodeStruct,1);
    RecordAllocation( Matrix, (char *)Matrix->FirstFillinListNode );
    if (Matrix->Error == spNO_MEMORY) return 0;
    Matrix->LastFillinListNode = Matrix->FirstFillinListNode;

    Matrix->FirstFillinListNode->pFillinList = pElement;
    Matrix->FirstFillinListNode->NumberOfFillinsInList =NumberOfFillinsExpected;
    Matrix->FirstFillinListNode->Next = NULL;

    return 0;
}

Here is the call graph for this function:

static InitializeElementBlocks

(

)

[static]

Referenced by spCreate().

Here is the caller graph for this function:

static RecordAllocation	(	MatrixPtr	Matrix,
		char *	AllocatedPtr
	)			[static]

Definition at line 511 of file spAllocate.c.

References AllocateBlockOfAllocationList(), NULL, SPFREE, and spNO_MEMORY.

{
/* Begin `RecordAllocation'. */
/*
 * If Allocated pointer is NULL, assume that malloc returned a NULL pointer,
 * which indicates a spNO_MEMORY error.
 */
    if (AllocatedPtr == NULL)
    {   Matrix->Error = spNO_MEMORY;
        return 0;
    }

/* Allocate block of MatrixElements if necessary. */
    if (Matrix->RecordsRemaining == 0)
    {   AllocateBlockOfAllocationList( Matrix );
        if (Matrix->Error == spNO_MEMORY)
        {   SPFREE(AllocatedPtr);
            return 0;
        }
    }

/* Add Allocated pointer to Allocation List. */
    (++Matrix->TopOfAllocationList)->AllocatedPtr = AllocatedPtr;
    Matrix->RecordsRemaining--;
    return 0;

}

Here is the call graph for this function:

static RecordAllocation

(

)

[static]

Referenced by InitializeElementBlocks(), spcGetElement(), spcGetFillin(), and spCreate().

Here is the caller graph for this function:

ElementPtr spcGetElement

(

MatrixPtr

Matrix

)

Definition at line 307 of file spAllocate.c.

References NULL, RecordAllocation(), SPALLOC, and spNO_MEMORY.

Referenced by spcCreateElement(), and spcGetFillin().

{
ElementPtr  pElement;

/* Begin `spcGetElement'. */

/* Allocate block of MatrixElements if necessary. */
    if (Matrix->ElementsRemaining == 0)
    {   pElement = SPALLOC(struct MatrixElement, ELEMENTS_PER_ALLOCATION);
        RecordAllocation( Matrix, (char *)pElement );
        if (Matrix->Error == spNO_MEMORY) return NULL;
        Matrix->ElementsRemaining = ELEMENTS_PER_ALLOCATION;
        Matrix->NextAvailElement = pElement;
    }

/* Update Element counter and return pointer to Element. */
    Matrix->ElementsRemaining--;
    return Matrix->NextAvailElement++;

}

Here is the call graph for this function:

Here is the caller graph for this function:

ElementPtr spcGetFillin

(

MatrixPtr

Matrix

)

Definition at line 434 of file spAllocate.c.

References FillinListNodeStruct::Next, NULL, FillinListNodeStruct::NumberOfFillinsInList, FillinListNodeStruct::pFillinList, RecordAllocation(), SPALLOC, spcGetElement(), and spNO_MEMORY.

Referenced by spcCreateElement().

{
struct FillinListNodeStruct *pListNode;
ElementPtr  pFillins;

/* Begin `spcGetFillin'. */

#if NOT STRIP OR LINT
    if (Matrix->FillinsRemaining == 0)
        return spcGetElement( Matrix );
#endif
#if STRIP OR LINT

    if (Matrix->FillinsRemaining == 0)
    {   pListNode = Matrix->LastFillinListNode;

/* First see if there are any stripped fill-ins left. */
        if (pListNode->Next != NULL)
        {   Matrix->LastFillinListNode = pListNode = pListNode->Next;
            Matrix->FillinsRemaining = pListNode->NumberOfFillinsInList;
            Matrix->NextAvailFillin = pListNode->pFillinList;
        }
        else
        {
/* Allocate block of fill-ins. */
            pFillins = SPALLOC(struct MatrixElement, ELEMENTS_PER_ALLOCATION);
            RecordAllocation( Matrix, (char *)pFillins );
            if (Matrix->Error == spNO_MEMORY) return NULL;
            Matrix->FillinsRemaining = ELEMENTS_PER_ALLOCATION;
            Matrix->NextAvailFillin = pFillins;

/* Allocate a fill-in list structure. */
            pListNode->Next = SPALLOC(struct FillinListNodeStruct,1);
            RecordAllocation( Matrix, (char *)pListNode->Next );
            if (Matrix->Error == spNO_MEMORY) return NULL;
            Matrix->LastFillinListNode = pListNode = pListNode->Next;

            pListNode->pFillinList = pFillins;
            pListNode->NumberOfFillinsInList = ELEMENTS_PER_ALLOCATION;
            pListNode->Next = NULL;
        }
    }
#endif

/* Update Fill-in counter and return pointer to Fill-in. */
    Matrix->FillinsRemaining--;
    return Matrix->NextAvailFillin++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* spCreate	(	int	Size,
		SPBOOLEAN	Complex,
		int *	pError
	)

Definition at line 113 of file spAllocate.c.

References AND, I, InitializeElementBlocks(), MAX, NO, NOT, NULL, OR, RecordAllocation(), SPALLOC, SPARSE_ID, SPCALLOC, spDestroy(), spNO_MEMORY, spOKAY, spPANIC, and YES.

{
register  unsigned  SizePlusOne;
register  MatrixPtr  Matrix;
register  int  I;
int  AllocatedSize;

/* Begin `spCreate'. */
/* Clear error flag. */
    *pError = spOKAY;

/* Test for valid size. */
    if ((Size < 0) OR (Size == 0 AND NOT EXPANDABLE))
    {   *pError = spPANIC;
        return NULL;
    }

/* Test for valid type. */
#if NOT spCOMPLEX
    if (Complex)
    {   *pError = spPANIC;
        return NULL;
    }
#endif
#if NOT REAL
    if (NOT Complex)
    {   *pError = spPANIC;
        return NULL;
    }
#endif

/* Create Matrix. */
    AllocatedSize = MAX( Size, MINIMUM_ALLOCATED_SIZE );
    SizePlusOne = (unsigned)(AllocatedSize + 1);

    if ((Matrix = SPALLOC(struct MatrixFrame, 1)) == NULL)
    {   *pError = spNO_MEMORY;
        return NULL;
    }

/* Initialize matrix */
    Matrix->ID = SPARSE_ID;
    Matrix->Complex = Complex;
    Matrix->PreviousMatrixWasComplex = Complex;
    Matrix->Factored = NO;
    Matrix->Elements = 0;
    Matrix->Error = *pError;
    Matrix->Fillins = 0;
    Matrix->Reordered = NO;
    Matrix->NeedsOrdering = YES;
    Matrix->NumberOfInterchangesIsOdd = NO;
    Matrix->Partitioned = NO;
    Matrix->RowsLinked = NO;
    Matrix->InternalVectorsAllocated = NO;
    Matrix->SingularCol = 0;
    Matrix->SingularRow = 0;
    Matrix->Size = Size;
    Matrix->AllocatedSize = AllocatedSize;
    Matrix->ExtSize = Size;
    Matrix->AllocatedExtSize = AllocatedSize;
    Matrix->CurrentSize = 0;
    Matrix->ExtToIntColMap = NULL;
    Matrix->ExtToIntRowMap = NULL;
    Matrix->IntToExtColMap = NULL;
    Matrix->IntToExtRowMap = NULL;
    Matrix->MarkowitzRow = NULL;
    Matrix->MarkowitzCol = NULL;
    Matrix->MarkowitzProd = NULL;
    Matrix->DoCmplxDirect = NULL;
    Matrix->DoRealDirect = NULL;
    Matrix->Intermediate = NULL;
    Matrix->RelThreshold = DEFAULT_THRESHOLD;
    Matrix->AbsThreshold = 0.0;

    Matrix->TopOfAllocationList = NULL;
    Matrix->RecordsRemaining = 0;
    Matrix->ElementsRemaining = 0;
    Matrix->FillinsRemaining = 0;

    RecordAllocation( Matrix, (char *)Matrix );
    if (Matrix->Error == spNO_MEMORY) goto MemoryError; 

/* Take out the trash. */
    Matrix->TrashCan.Real = 0.0;
#if spCOMPLEX
    Matrix->TrashCan.Imag = 0.0;
#endif
    Matrix->TrashCan.Row = 0;
    Matrix->TrashCan.Col = 0;
    Matrix->TrashCan.NextInRow = NULL;
    Matrix->TrashCan.NextInCol = NULL;
#if INITIALIZE
    Matrix->TrashCan.pInitInfo = NULL;
#endif

/* Allocate space in memory for Diag pointer vector. */
    SPCALLOC( Matrix->Diag, ElementPtr, SizePlusOne);
    if (Matrix->Diag == NULL)
        goto MemoryError;

/* Allocate space in memory for FirstInCol pointer vector. */
    SPCALLOC( Matrix->FirstInCol, ElementPtr, SizePlusOne);
    if (Matrix->FirstInCol == NULL)
        goto MemoryError;

/* Allocate space in memory for FirstInRow pointer vector. */
    SPCALLOC( Matrix->FirstInRow, ElementPtr, SizePlusOne);
    if (Matrix->FirstInRow == NULL)
        goto MemoryError;

/* Allocate space in memory for IntToExtColMap vector. */
    if (( Matrix->IntToExtColMap = SPALLOC(int, SizePlusOne)) == NULL)
        goto MemoryError;

/* Allocate space in memory for IntToExtRowMap vector. */
    if (( Matrix->IntToExtRowMap = SPALLOC(int, SizePlusOne)) == NULL)
        goto MemoryError;

/* Initialize MapIntToExt vectors. */
    for (I = 1; I <= AllocatedSize; I++)
    {   Matrix->IntToExtRowMap[I] = I;
        Matrix->IntToExtColMap[I] = I;
    }

#if TRANSLATE
/* Allocate space in memory for ExtToIntColMap vector. */
    if (( Matrix->ExtToIntColMap = SPALLOC(int, SizePlusOne)) == NULL)
        goto MemoryError;

/* Allocate space in memory for ExtToIntRowMap vector. */
    if (( Matrix->ExtToIntRowMap = SPALLOC(int, SizePlusOne)) == NULL)
        goto MemoryError;

/* Initialize MapExtToInt vectors. */
    for (I = 1; I <= AllocatedSize; I++)
    {   Matrix->ExtToIntColMap[I] = -1;
        Matrix->ExtToIntRowMap[I] = -1;
    }
    Matrix->ExtToIntColMap[0] = 0;
    Matrix->ExtToIntRowMap[0] = 0;
#endif

/* Allocate space for fill-ins and initial set of elements. */
    InitializeElementBlocks( Matrix, SPACE_FOR_ELEMENTS*AllocatedSize,
                                     SPACE_FOR_FILL_INS*AllocatedSize );
    if (Matrix->Error == spNO_MEMORY)
        goto MemoryError;

    return (char *)Matrix;

MemoryError:

/* Deallocate matrix and return no pointer to matrix if there is not enough
   memory. */
    *pError = spNO_MEMORY;
    spDestroy( (char *)Matrix);
    return NULL;
}

Here is the call graph for this function:

void spDestroy

(

char *

eMatrix

)

Definition at line 629 of file spAllocate.c.

References AllocationRecord::AllocatedPtr, ASSERT, free(), IS_SPARSE, AllocationRecord::NextRecord, NULL, and SPFREE.

{
MatrixPtr Matrix = (MatrixPtr)eMatrix;
register  AllocationListPtr  ListPtr, NextListPtr;


/* Begin `spDestroy'. */
    ASSERT( IS_SPARSE( Matrix ) );

/* Deallocate the vectors that are located in the matrix frame. */
    SPFREE( Matrix->IntToExtColMap );
    SPFREE( Matrix->IntToExtRowMap );
    SPFREE( Matrix->ExtToIntColMap );
    SPFREE( Matrix->ExtToIntRowMap );
    SPFREE( Matrix->Diag );
    SPFREE( Matrix->FirstInRow );
    SPFREE( Matrix->FirstInCol );
    SPFREE( Matrix->MarkowitzRow );
    SPFREE( Matrix->MarkowitzCol );
    SPFREE( Matrix->MarkowitzProd );
    SPFREE( Matrix->DoCmplxDirect );
    SPFREE( Matrix->DoRealDirect );
    SPFREE( Matrix->Intermediate );


/* Sequentially step through the list of allocated pointers freeing pointers
 * along the way. */

    ListPtr = Matrix->TopOfAllocationList;
    while (ListPtr != NULL )
    { 
      char *LocPtr;
      /* dans certain cas le pointeur ds la zone a desalouer
         se trouve lui meme ds la dite zone en fait quand 
         ( ListPtr ==  ListPtr->AllocatedPtr )
         donc un free(x) suivit de x=0 
         fait que l'on essaye d'ecrire ds une zone que l'on vient de desalouer
         ce qui plante sur linux 
         fprintf(stderr,"Warning bad SPFREE\n");
         je regle le probleme en mettant a zero avant le free !
         */
      NextListPtr = ListPtr->NextRecord;
      /* BUGUED : SPFREE( ListPtr->AllocatedPtr) */
      LocPtr=ListPtr->AllocatedPtr;
      ListPtr->AllocatedPtr= NULL;
      if ( LocPtr != NULL) free(LocPtr);
      ListPtr = NextListPtr;
    }
    return;
}

Here is the call graph for this function:

int spElementCount

(

char *

eMatrix

)

Definition at line 874 of file spAllocate.c.

References ASSERT, and IS_SPARSE.

{
/* Begin `spElementCount'. */

    ASSERT( IS_SPARSE( (MatrixPtr)eMatrix ) );
    return ((MatrixPtr)eMatrix)->Elements;
}

int spError

(

char *

eMatrix

)

Definition at line 702 of file spAllocate.c.

References ASSERT, NULL, SPARSE_ID, and spNO_MEMORY.

{
/* Begin `spError'. */

    if (eMatrix != NULL)
    {   ASSERT(((MatrixPtr)eMatrix)->ID == SPARSE_ID);
        return ((MatrixPtr)eMatrix)->Error;
    }
    else return spNO_MEMORY;   /* This error may actually be spPANIC,
                                * no way to tell. */
}

int spFillinCount

(

char *

eMatrix

)

Definition at line 862 of file spAllocate.c.

References ASSERT, and IS_SPARSE.

{
/* Begin `spFillinCount'. */

    ASSERT( IS_SPARSE( (MatrixPtr)eMatrix ) );
    return ((MatrixPtr)eMatrix)->Fillins;
}

int spGetSize	(	char *	eMatrix,
		SPBOOLEAN	External
	)

Definition at line 780 of file spAllocate.c.

References ASSERT, and IS_SPARSE.

{
MatrixPtr Matrix = (MatrixPtr)eMatrix;

/* Begin `spGetSize'. */
    ASSERT( IS_SPARSE( Matrix ) );

#if TRANSLATE
    if (External)
        return Matrix->ExtSize;
    else
        return Matrix->Size;
#else
    return Matrix->Size;
#endif
}

void spSetComplex

(

char *

eMatrix

)

Definition at line 831 of file spAllocate.c.

References AND, ASSERT, IS_SPARSE, spCOMPLEX, and YES.

{
/* Begin `spSetComplex'. */

    ASSERT( IS_SPARSE( (MatrixPtr)eMatrix ) AND spCOMPLEX);
    ((MatrixPtr)eMatrix)->Complex = YES;
    return;
}

void spSetReal

(

char *

eMatrix

)

Definition at line 818 of file spAllocate.c.

References AND, ASSERT, IS_SPARSE, NO, and REAL.

{
/* Begin `spSetReal'. */

    ASSERT( IS_SPARSE( (MatrixPtr)eMatrix ) AND REAL);
    ((MatrixPtr)eMatrix)->Complex = NO;
    return;
}

void spWhereSingular	(	char *	eMatrix,
		int *	pRow,
		int *	pCol
	)

Definition at line 740 of file spAllocate.c.

References ASSERT, IS_SPARSE, OR, spSINGULAR, and spZERO_DIAG.

{
MatrixPtr Matrix = (MatrixPtr)eMatrix;

/* Begin `spWhereSingular'. */
    ASSERT( IS_SPARSE( Matrix ) );

    if (Matrix->Error == spSINGULAR OR Matrix->Error == spZERO_DIAG)
    {   *pRow = Matrix->SingularRow;
        *pCol = Matrix->SingularCol;
    }
    else *pRow = *pCol = 0;
    return;
}

---