SRC/zmemory.c File Reference

Memory details. More...

#include "slu_zdefs.h"

Defines
#define	StackFull(x)   ( x + Glu->stack.used >= Glu->stack.size )
#define	NotDoubleAlign(addr)   ( (long int)addr & 7 )
#define	DoubleAlign(addr)   ( ((long int)addr + 7) & ~7L )
#define	TempSpace(m, w)
#define	Reduce(alpha)   ((alpha + 1) / 2)
Functions
void *	zexpand (int *prev_len,MemType type,int len_to_copy,int keep_prev,GlobalLU_t *Glu)
	Expand the existing storage to accommodate more fill-ins.
int	zLUWorkInit (int m, int n, int panel_size, int **iworkptr, doublecomplex **dworkptr, GlobalLU_t *Glu)
	Allocate known working storage. Returns 0 if success, otherwise returns the number of bytes allocated so far when failure occurred.
void	copy_mem_doublecomplex (int, void *, void *)
void	zStackCompress (GlobalLU_t *Glu)
	Compress the work[] array to remove fragmentation.
void	zSetupSpace (void *work, int lwork, GlobalLU_t *Glu)
	Setup the memory model to be used for factorization.
void *	zuser_malloc (int, int, GlobalLU_t *)
void	zuser_free (int, int, GlobalLU_t *)
void	copy_mem_int (int, void *, void *)
void	user_bcopy (char *, char *, int)
int	zQuerySpace (SuperMatrix *L, SuperMatrix *U, mem_usage_t *mem_usage)
int	ilu_zQuerySpace (SuperMatrix *L, SuperMatrix *U, mem_usage_t *mem_usage)
int	zLUMemInit (fact_t fact, void *work, int lwork, int m, int n, int annz, int panel_size, double fill_ratio, SuperMatrix *L, SuperMatrix *U, GlobalLU_t *Glu, int **iwork, doublecomplex **dwork)
	Allocate storage for the data structures common to all factor routines.
void	zSetRWork (int m, int panel_size, doublecomplex *dworkptr, doublecomplex **dense, doublecomplex **tempv)
	Set up pointers for real working arrays.
void	zLUWorkFree (int *iwork, doublecomplex *dwork, GlobalLU_t *Glu)
	Free the working storage used by factor routines.
int	zLUMemXpand (int jcol, int next, MemType mem_type, int *maxlen, GlobalLU_t *Glu)
	Expand the data structures for L and U during the factorization.
void	zallocateA (int n, int nnz, doublecomplex **a, int **asub, int **xa)
	Allocate storage for original matrix A.
doublecomplex *	doublecomplexMalloc (int n)
doublecomplex *	doublecomplexCalloc (int n)
int	zmemory_usage (const int nzlmax, const int nzumax, const int nzlumax, const int n)

---

Detailed Description

 -- SuperLU routine (version 4.0) --
 Lawrence Berkeley National Laboratory.
 June 30, 2009
 

---

Define Documentation

#define DoubleAlign

(

addr

)

( ((long int)addr + 7) & ~7L )

#define NotDoubleAlign

(

addr

)

( (long int)addr & 7 )

#define Reduce

(

alpha

)

((alpha + 1) / 2)

#define StackFull

(

x

)

( x + Glu->stack.used >= Glu->stack.size )

#define TempSpace	(	m,
		w		)

Value:

( (2*w + 4 + NO_MARKER) * m * sizeof(int) + \
                              (w + 1) * m * sizeof(doublecomplex) )

---

Function Documentation

void copy_mem_doublecomplex	(	int	howmany,
		void *	old,
		void *	new
	)

void copy_mem_int	(	int	,
		void *	,
		void *
	)

doublecomplex* doublecomplexCalloc

(

int

n

)

doublecomplex* doublecomplexMalloc

(

int

n

)

int ilu_zQuerySpace	(	SuperMatrix *	L,
		SuperMatrix *	U,
		mem_usage_t *	mem_usage
	)

 mem_usage consists of the following fields:

for_lu (float)
      The amount of space used in bytes for the L data structures.
total_needed (float)
      The amount of space needed in bytes to perform factorization.
 

void user_bcopy	(	char *	,
		char *	,
		int
	)

void zallocateA	(	int	n,
		int	nnz,
		doublecomplex **	a,
		int **	asub,
		int **	xa
	)

void * zexpand	(	int *	prev_len,
		MemType	type,
		int	len_to_copy,
		int	keep_prev,
		GlobalLU_t *	Glu
	)

int zLUMemInit	(	fact_t	fact,
		void *	work,
		int	lwork,
		int	m,
		int	n,
		int	annz,
		int	panel_size,
		double	fill_ratio,
		SuperMatrix *	L,
		SuperMatrix *	U,
		GlobalLU_t *	Glu,
		int **	iwork,
		doublecomplex **	dwork
	)

Memory-related.

 For those unpredictable size, estimate as fill_ratio * nnz(A).
 Return value:
     If lwork = -1, return the estimated amount of space required, plus n;
     otherwise, return the amount of space actually allocated when
     memory allocation failure occurred.
 

int zLUMemXpand	(	int	jcol,
		int	next,
		MemType	mem_type,
		int *	maxlen,
		GlobalLU_t *	Glu
	)

 Return value:   0 - successful return
               > 0 - number of bytes allocated when run out of space
 

void zLUWorkFree	(	int *	iwork,
		doublecomplex *	dwork,
		GlobalLU_t *	Glu
	)

int zLUWorkInit	(	int	m,
		int	n,
		int	panel_size,
		int **	iworkptr,
		doublecomplex **	dworkptr,
		GlobalLU_t *	Glu
	)

int zmemory_usage	(	const int	nzlmax,
		const int	nzumax,
		const int	nzlumax,
		const int	n
	)

int zQuerySpace	(	SuperMatrix *	L,
		SuperMatrix *	U,
		mem_usage_t *	mem_usage
	)

 mem_usage consists of the following fields:

for_lu (float)
      The amount of space used in bytes for the L data structures.
total_needed (float)
      The amount of space needed in bytes to perform factorization.
 

void zSetRWork	(	int	m,
		int	panel_size,
		doublecomplex *	dworkptr,
		doublecomplex **	dense,
		doublecomplex **	tempv
	)

void zSetupSpace	(	void *	work,
		int	lwork,
		GlobalLU_t *	Glu
	)

lwork = 0: use system malloc; lwork > 0: use user-supplied work[] space.

void zStackCompress

(

GlobalLU_t *

Glu

)

void zuser_free	(	int	bytes,
		int	which_end,
		GlobalLU_t *	Glu
	)

void * zuser_malloc	(	int	bytes,
		int	which_end,
		GlobalLU_t *	Glu
	)