# 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 |
| ) |  |  |