SuperLU  5.0
Macros | Functions
zmemory.c File Reference

Memory details. More...

#include "slu_zdefs.h"
Include dependency graph for zmemory.c:

Macros

#define StackFull(x)   ( x + Glu->stack.used >= Glu->stack.size )
 
#define NotDoubleAlign(addr)   ( (intptr_t)addr & 7 )
 
#define DoubleAlign(addr)   ( ((intptr_t)addr + 7) & ~7L )
 
#define TempSpace(m, w)
 
#define Reduce(alpha)   ((alpha + 1) / 2) /* i.e. (alpha-1)/2 + 1 */
 

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. More...
 
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. More...
 
void copy_mem_doublecomplex (int, void *, void *)
 
void zStackCompress (GlobalLU_t *Glu)
 Compress the work[] array to remove fragmentation. More...
 
void zSetupSpace (void *work, int lwork, GlobalLU_t *Glu)
 Setup the memory model to be used for factorization. More...
 
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. More...
 
void zSetRWork (int m, int panel_size, doublecomplex *dworkptr, doublecomplex **dense, doublecomplex **tempv)
 Set up pointers for real working arrays. More...
 
void zLUWorkFree (int *iwork, doublecomplex *dwork, GlobalLU_t *Glu)
 Free the working storage used by factor routines. More...
 
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. More...
 
void zallocateA (int n, int nnz, doublecomplex **a, int **asub, int **xa)
 Allocate storage for original matrix A. More...
 
doublecomplexdoublecomplexMalloc (int n)
 
doublecomplexdoublecomplexCalloc (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

Macro Definition Documentation

#define DoubleAlign (   addr)    ( ((intptr_t)addr + 7) & ~7L )
#define NotDoubleAlign (   addr)    ( (intptr_t)addr & 7 )
#define Reduce (   alpha)    ((alpha + 1) / 2) /* i.e. (alpha-1)/2 + 1 */
#define StackFull (   x)    ( x + Glu->stack.used >= Glu->stack.size )
#define TempSpace (   m,
 
)
Value:
( (2*w + 4 + NO_MARKER) * m * sizeof(int) + \
(w + 1) * m * sizeof(doublecomplex) )
#define NO_MARKER
Definition: slu_util.h:31
Definition: slu_dcomplex.h:21

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.

Here is the call graph for this function:

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

Here is the call graph for this function:

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

Here is the call graph for this function:

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.

Here is the call graph for this function:

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

Here is the call graph for this function:

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 
)

Here is the call graph for this function:

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.

Here is the call graph for this function:

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

Here is the call graph for this function:

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)

Here is the call graph for this function:

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