SuperLU: SRC/dmemory.c File Reference

SuperLU 5.3.0

Macros | Functions
dmemory.c File Reference

Memory details. More...

`#include "slu_ddefs.h"`
Include dependency graph for dmemory.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 * | dexpand (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 | dLUWorkInit (int m, int n, int panel_size, int **iworkptr, double **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_double (int, void *, void *)
void | dStackCompress (GlobalLU_t *Glu)
| Compress the work[] array to remove fragmentation. More...
void | dSetupSpace (void *work, int lwork, GlobalLU_t *Glu)
| Setup the memory model to be used for factorization. More...
void * | duser_malloc (int, int, GlobalLU_t *)
void | duser_free (int, int, GlobalLU_t *)
void | copy_mem_int (int, void *, void *)
void | user_bcopy (char *, char *, int)
int | dQuerySpace (SuperMatrix *L, SuperMatrix *U, mem_usage_t *mem_usage)
int | ilu_dQuerySpace (SuperMatrix *L, SuperMatrix *U, mem_usage_t *mem_usage)
int | dLUMemInit (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, double **dwork)
| Allocate storage for the data structures common to all factor routines. More...
void | dSetRWork (int m, int panel_size, double *dworkptr, double **dense, double **tempv)
| Set up pointers for real working arrays. More...
void | dLUWorkFree (int *iwork, double *dwork, GlobalLU_t *Glu)
| Free the working storage used by factor routines. More...
int | dLUMemXpand (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 | dallocateA (int n, int nnz, double **a, int **asub, int **xa)
| Allocate storage for original matrix A. More...
double * | doubleMalloc (int n)
double * | doubleCalloc (int n)
int | dmemory_usage (const int nzlmax, const int nzumax, const int nzlumax, const int n)

## Detailed Description

Copyright (c) 2003, The Regents of the University of California, through Lawrence Berkeley National Laboratory (subject to receipt of any required approvals from U.S. Dept. of Energy)

All rights reserved.

The source code is distributed under BSD license, see the file License.txt at the top-level directory.

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

## Macro Definition Documentation

## ◆ DoubleAlign

#define DoubleAlign | ( |  | addr | ) | ( ((intptr_t)addr + 7) & ~7L )

## ◆ NotDoubleAlign

#define NotDoubleAlign | ( |  | addr | ) | ( (intptr_t)addr & 7 )

## ◆ Reduce

#define Reduce | ( |  | alpha | ) | ((alpha + 1) / 2) /* i.e. (alpha-1)/2 + 1 */

## ◆ StackFull

#define StackFull | ( |  | x | ) | ( x + Glu->stack.used >= Glu->stack.size )

## ◆ TempSpace

#define TempSpace | ( |  | m,
|  |  | w
| ) |  |

Value:
( (2*w + 4 + NO_MARKER) * m * sizeof(int) + \
(w + 1) * m * sizeof(double) )
NO_MARKER
#define NO_MARKER
Definition: slu_util.h:57

## Function Documentation

## ◆ copy_mem_double()

void copy_mem_double | ( | int | howmany,
|  | void * | old,
|  | void * | new
| ) |  |

## ◆ copy_mem_int()

void copy_mem_int | ( | int | ,
|  | void * | ,
|  | void * |
| ) |  |

## ◆ dallocateA()

void dallocateA | ( | int | n,
|  | int | nnz,
|  | double ** | a,
|  | int ** | asub,
|  | int ** | xa
| ) |  |

Here is the call graph for this function:

## ◆ dexpand()

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

Here is the call graph for this function:

## ◆ dLUMemInit()

int dLUMemInit | ( | 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,
|  | double ** | 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:

## ◆ dLUMemXpand()

int dLUMemXpand | ( | 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:

## ◆ dLUWorkFree()

void dLUWorkFree | ( | int * | iwork,
|  | double * | dwork,
|  | GlobalLU_t * | Glu
| ) |  |

## ◆ dLUWorkInit()

int dLUWorkInit | ( | int | m,
|  | int | n,
|  | int | panel_size,
|  | int ** | iworkptr,
|  | double ** | dworkptr,
|  | GlobalLU_t * | Glu
| ) |  |

Here is the call graph for this function:

## ◆ dmemory_usage()

int dmemory_usage | ( | const int | nzlmax,
|  | const int | nzumax,
|  | const int | nzlumax,
|  | const int | n
| ) |  |

## ◆ doubleCalloc()

double* doubleCalloc | ( | int | n | ) |

## ◆ doubleMalloc()

double* doubleMalloc | ( | int | n | ) |

## ◆ dQuerySpace()

int dQuerySpace | ( | 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\U data structures.
    total_needed (float)
         The amount of space needed in bytes to perform factorization.

Here is the call graph for this function:

## ◆ dSetRWork()

void dSetRWork | ( | int | m,
|  | int | panel_size,
|  | double * | dworkptr,
|  | double ** | dense,
|  | double ** | tempv
| ) |  |

Here is the call graph for this function:

## ◆ dSetupSpace()

void dSetupSpace | ( | void * | work,
|  | int | lwork,
|  | GlobalLU_t * | Glu
| ) |  |

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

## ◆ dStackCompress()

void dStackCompress | ( | GlobalLU_t * | Glu | ) |

Here is the call graph for this function:

## ◆ duser_free()

void duser_free | ( | int | bytes,
|  | int | which_end,
|  | GlobalLU_t * | Glu
| ) |  |

## ◆ duser_malloc()

void * duser_malloc | ( | int | bytes,
|  | int | which_end,
|  | GlobalLU_t * | Glu
| ) |  |

## ◆ ilu_dQuerySpace()

int ilu_dQuerySpace | ( | 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\U data structures.
    total_needed (float)
         The amount of space needed in bytes to perform factorization.

Here is the call graph for this function:

## ◆ user_bcopy()

void user_bcopy | ( | char * | ,
|  | char * | ,
|  | int |
| ) |  |